def setUp(self):
super().setUp()
# setup minimum eigen solvers
self.min_eigen_solvers = {}
# exact eigen solver
self.min_eigen_solvers["exact"] = NumPyMinimumEigensolver()
# QAOA
optimizer = COBYLA()
self.min_eigen_solvers["qaoa"] = QAOA(optimizer=optimizer)
# simulators
self.sv_simulator = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=123,
seed_transpiler=123,
)
self.qasm_simulator = QuantumInstance(
BasicAer.get_backend("qasm_simulator"),
seed_simulator=123,
seed_transpiler=123,
)
# test minimize
self.op_minimize = QuadraticProgram()
self.op_minimize.integer_var(0, 3, "x")
self.op_minimize.binary_var("y")
self.op_minimize.minimize(linear={"x": 1, "y": 2})
self.op_minimize.linear_constraint(linear={
"x": 1,
"y": 1
},
sense=">=",
rhs=1,
name="xy")
# test maximize
self.op_maximize = QuadraticProgram()
self.op_maximize.integer_var(0, 3, "x")
self.op_maximize.binary_var("y")
self.op_maximize.maximize(linear={"x": 1, "y": 2})
self.op_maximize.linear_constraint(linear={
"x": 1,
"y": 1
},
sense="<=",
rhs=1,
name="xy")
# test bit ordering
mdl = Model("docplex model")
x = mdl.binary_var("x")
y = mdl.binary_var("y")
mdl.minimize(x - 2 * y)
self.op_ordering = from_docplex_mp(mdl)
def test_numpy_mes(self):
"""Test NumPyMinimumEigenSolver with QEOM"""
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, "sd")
results = esc.solve(self.electronic_structure_problem)
for idx, energy in enumerate(self.reference_energies):
self.assertAlmostEqual(results.computed_energies[idx],
energy,
places=4)
def test_simple2(self):
""" simple2 test """
# Computes the cost using the exact eigensolver
# and compares it against pre-determined value.
result = NumPyMinimumEigensolver().compute_minimum_eigenvalue(
operator=self.qubit_op)
quantum_solution = get_portfoliodiversification_solution(
self.instance, self.n, self.q, result)
ground_level = get_portfoliodiversification_value(
self.instance, self.n, self.q, quantum_solution)
np.testing.assert_approx_equal(ground_level, 1.8)
def test_aux_operators_list(self):
"""Test list-based aux_operators."""
aux_op1 = PauliSumOp.from_list([("II", 2.0)])
aux_op2 = PauliSumOp.from_list([("II", 0.5), ("ZZ", 0.5), ("YY", 0.5),
("XX", -0.5)])
aux_ops = [aux_op1, aux_op2]
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=aux_ops)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
# expectation values
self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0],
2,
places=6)
self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0],
0,
places=6)
# standard deviations
self.assertAlmostEqual(result.aux_operator_eigenvalues[0][1], 0.0)
self.assertAlmostEqual(result.aux_operator_eigenvalues[1][1], 0.0)
# Go again with additional None and zero operators
extra_ops = [*aux_ops, None, 0]
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=extra_ops)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 4)
# expectation values
self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0],
2,
places=6)
self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0],
0,
places=6)
self.assertIsNone(result.aux_operator_eigenvalues[2], None)
self.assertEqual(result.aux_operator_eigenvalues[3][0], 0.0)
# standard deviations
self.assertAlmostEqual(result.aux_operator_eigenvalues[0][1], 0.0)
self.assertAlmostEqual(result.aux_operator_eigenvalues[1][1], 0.0)
self.assertEqual(result.aux_operator_eigenvalues[3][1], 0.0)
def setUp(self):
super().setUp()
# setup minimum eigen solvers
self.min_eigen_solvers = {}
# exact eigen solver
self.min_eigen_solvers['exact'] = NumPyMinimumEigensolver()
# QAOA
optimizer = COBYLA()
self.min_eigen_solvers['qaoa'] = QAOA(optimizer=optimizer)
def validate_results(self, problem, results):
"""Validate the results object returned by GroverOptimizer."""
# Get expected value.
solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
comp_result = solver.solve(problem)
# Validate results.
np.testing.assert_array_almost_equal(comp_result.x, results.x)
self.assertEqual(comp_result.fval, results.fval)
# optimizer internally deals with minimization problem
self.assertAlmostEqual(
results.fval,
problem.objective.sense.value * results.intermediate_fval)
def test_min_eigen_optimizer_history(self):
"""Tests different options for history."""
try:
filename = 'op_ip1.lp'
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(path.join('resources', filename))
problem.read_from_lp_file(lp_file)
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# no history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.NO_ITERATIONS)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNone(result.history[1])
# only last iteration in the history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.LAST_ITERATION)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNotNone(result.history[1])
# full history
recursive_min_eigen_optimizer = \
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.ALL_ITERATIONS)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertGreater(len(result.history[0]), 1)
self.assertIsNotNone(result.history[1])
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_samples_numpy_eigen_solver(self):
"""Test samples for NumPyMinimumEigensolver"""
# test minimize
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(self.op_minimize)
opt_sol = 1
success = OptimizationResultStatus.SUCCESS
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, success)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x,
[1, 0, 0, 0, 0])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, success)
# test maximize
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(self.op_maximize)
opt_sol = 2
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, success)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x,
[0, 0, 1, 0])
# optimizer internally deals with minimization problem
self.assertAlmostEqual(
self.op_maximize.objective.sense.value *
result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, success)
def test_docplex_tsp(self):
""" Docplex tsp test """
# Generating a graph of 3 nodes
n = 3
ins = tsp.random_tsp(n)
graph = rx.PyGraph()
graph.add_nodes_from(np.arange(0, n, 1).tolist())
num_node = ins.dim
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='tsp')
x = {(i, p): mdl.binary_var(name='x_{0}_{1}'.format(i, p))
for i in range(num_node) for p in range(num_node)}
tsp_func = mdl.sum(
ins.w[i, j] * x[(i, p)] * x[(j, (p + 1) % num_node)]
for i in range(num_node) for j in range(num_node) for p
in range(num_node))
mdl.minimize(tsp_func)
for i in range(num_node):
mdl.add_constraint(mdl.sum(x[(i, p)] for p in range(num_node)) == 1)
for j in range(num_node):
mdl.add_constraint(mdl.sum(x[(i, j)] for i in range(num_node)) == 1)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
ee_expected = NumPyMinimumEigensolver()
expected_result = ee_expected.compute_minimum_eigenvalue(operator=QUBIT_OP_TSP)
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result.eigenvalue.real + OFFSET_TSP)
def test_docplex_maxcut(self):
""" Docplex maxcut test """
# Generating a graph of 4 nodes
n = 4
graph = rx.PyGraph()
graph.add_nodes_from(np.arange(0, n, 1).tolist())
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]
graph.add_edges_from(elist)
# Computing the weight matrix from the random graph
w = rx.graph_adjacency_matrix(graph, lambda weight: weight)
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(4)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] * (1 - mdl.node_vars[j])
for i in range(n) for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
ee_expected = NumPyMinimumEigensolver()
expected_result = ee_expected.compute_minimum_eigenvalue(operator=QUBIT_OP_MAXCUT)
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result.eigenvalue.real + OFFSET_MAXCUT)
def test_recursive_history(self):
"""Tests different options for history."""
filename = "op_ip1.lp"
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(filename, "algorithms/resources")
problem.read_from_lp_file(lp_file)
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# no history
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.NO_ITERATIONS,
)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNone(result.history[1])
# only last iteration in the history
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.LAST_ITERATION,
)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertEqual(len(result.history[0]), 0)
self.assertIsNotNone(result.history[1])
# full history
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer,
min_num_vars=4,
history=IntermediateResult.ALL_ITERATIONS,
)
result = recursive_min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result.replacements)
self.assertIsNotNone(result.history)
self.assertIsNotNone(result.history[0])
self.assertGreater(len(result.history[0]), 1)
self.assertIsNotNone(result.history[1])
def _run_driver(driver: FermionicDriver,
converter: QubitConverter = QubitConverter(
JordanWignerMapper()),
transformers: Optional[List[BaseTransformer]] = None):
problem = ElectronicStructureProblem(driver, transformers)
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(converter, solver)
result = gsc.solve(problem)
return result
def __init__(
self,
optimizer: OptimizationAlgorithm,
min_num_vars: int = 1,
min_num_vars_optimizer: Optional[OptimizationAlgorithm] = None,
penalty: Optional[float] = None,
history: Optional[IntermediateResult] = IntermediateResult.
LAST_ITERATION,
converters: Optional[Union[QuadraticProgramConverter,
List[QuadraticProgramConverter]]] = None,
) -> None:
"""Initializes the recursive minimum eigen optimizer.
This initializer takes an ``OptimizationAlgorithm``, the parameters to specify until when to
to apply the iterative scheme, and the optimizer to be applied once the threshold number of
variables is reached.
Args:
optimizer: The optimizer to use in every iteration.
min_num_vars: The minimum number of variables to apply the recursive scheme. If this
threshold is reached, the min_num_vars_optimizer is used.
min_num_vars_optimizer: This optimizer is used after the recursive scheme for the
problem with the remaining variables. Default value is
:class:`~qiskit_optimization.algorithms.MinimumEigenOptimizer` created on top of
:class:`~qiskit.algorithms.minimum_eigen_solver.NumPyMinimumEigensolver`.
penalty: The factor that is used to scale the penalty terms corresponding to linear
equality constraints.
history: Whether the intermediate results are stored.
Default value is :py:obj:`~IntermediateResult.LAST_ITERATION`.
converters: The converters to use for converting a problem into a different form.
By default, when None is specified, an internally created instance of
:class:`~qiskit_optimization.converters.QuadraticProgramToQubo` will be used.
Raises:
QiskitOptimizationError: In case of invalid parameters (num_min_vars < 1).
TypeError: When there one of converters is an invalid type.
"""
validate_min("min_num_vars", min_num_vars, 1)
self._optimizer = optimizer
self._min_num_vars = min_num_vars
if min_num_vars_optimizer:
self._min_num_vars_optimizer = min_num_vars_optimizer
else:
self._min_num_vars_optimizer = MinimumEigenOptimizer(
NumPyMinimumEigensolver())
self._penalty = penalty
self._history = history
self._converters = self._prepare_converters(converters, penalty)
def test_min_eigen_optimizer_with_filter(self, config):
""" Min Eigen Optimizer Test """
try:
# unpack configuration
filename, lowerbound, fval, status = config
# get minimum eigen solver
min_eigen_solver = NumPyMinimumEigensolver()
# set filter
# pylint: disable=unused-argument
def filter_criterion(x, v, aux):
return v > lowerbound
min_eigen_solver.filter_criterion = filter_criterion
# construct minimum eigen optimizer
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# load optimization problem
problem = QuadraticProgram()
lp_file = self.get_resource_path(filename, 'algorithms/resources')
problem.read_from_lp_file(lp_file)
# solve problem
result = min_eigen_optimizer.solve(problem)
self.assertIsNotNone(result)
# analyze results
self.assertAlmostEqual(fval, result.fval)
self.assertEqual(status, result.status)
# check that eigensolver result is present
self.assertIsNotNone(result.min_eigen_solver_result)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
except RuntimeError as ex:
self.fail(str(ex))
def __init__(
self,
use_default_filter_criterion: bool = False,
**kwargs,
) -> None:
"""
Args:
use_default_filter_criterion: whether to use the transformation's default filter
criterion.
kwargs: keyword arguments passed to NumpyMinimumEigensolver to construct
the internal `MinimumEigensolver`.
"""
self._use_default_filter_criterion = use_default_filter_criterion
self._minimum_eigensolver = NumPyMinimumEigensolver(**kwargs)
def get_solver(self, transformation: Transformation) -> MinimumEigensolver:
"""Returns a NumPyMinimumEigensolver which possibly uses the default filter criterion
provided by the ``transformation``.
Args:
transformation: a fermionic/bosonic qubit operator transformation.
Returns:
A NumPyMinimumEigensolver suitable to compute the ground state of the molecule
transformed by ``transformation``.
"""
filter_criterion = self._filter_criterion
if not filter_criterion and self._use_default_filter_criterion:
filter_criterion = transformation.get_default_filter_criterion()
npme = NumPyMinimumEigensolver(filter_criterion=filter_criterion)
return npme
def test_auto_penalty(self):
""" Test auto penalty function"""
op = QuadraticProgram()
op.binary_var('x')
op.binary_var('y')
op.binary_var('z')
op.minimize(constant=3, linear={'x': 1}, quadratic={('x', 'y'): 2})
op.linear_constraint(linear={'x': 1, 'y': 1, 'z': 1}, sense='EQ', rhs=2, name='xyz_eq')
lineq2penalty = LinearEqualityToPenalty(penalty=1e5)
lineq2penalty_auto = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(op)
qubo_auto = lineq2penalty_auto.convert(op)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
result = exact.solve(qubo)
result_auto = exact.solve(qubo_auto)
self.assertEqual(result.fval, result_auto.fval)
np.testing.assert_array_almost_equal(result.x, result_auto.x)
def test_linear_equality_to_penalty_decode(self):
""" Test decode func of LinearEqualityToPenalty"""
qprog = QuadraticProgram()
qprog.binary_var('x')
qprog.binary_var('y')
qprog.binary_var('z')
qprog.maximize(linear={'x': 3, 'y': 1, 'z': 1})
qprog.linear_constraint(linear={'x': 1, 'y': 1, 'z': 1}, sense='EQ', rhs=2, name='xyz_eq')
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qprog)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
result = exact.solve(qubo)
new_x = lineq2penalty.interpret(result.x)
np.testing.assert_array_almost_equal(new_x, [1, 1, 0])
infeasible_x = lineq2penalty.interpret([1, 1, 1])
np.testing.assert_array_almost_equal(infeasible_x, [1, 1, 1])
def get_solver(self, problem: BaseProblem,
qubit_converter: QubitConverter) -> MinimumEigensolver:
"""Returns a NumPyMinimumEigensolver which possibly uses the default filter criterion
provided by the ``problem``.
Args:
problem: a class encoding a problem to be solved.
qubit_converter: a class that converts second quantized operator to qubit operator
according to a mapper it is initialized with.
Returns:
A NumPyMinimumEigensolver suitable to compute the ground state of the molecule.
"""
filter_criterion = self._filter_criterion
if not filter_criterion and self._use_default_filter_criterion:
filter_criterion = problem.get_default_filter_criterion()
npme = NumPyMinimumEigensolver(filter_criterion=filter_criterion)
return npme
def _run_driver(driver,
transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True):
fermionic_transformation = \
FermionicTransformation(transformation=transformation,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
freeze_core=freeze_core,
orbital_reduction=[])
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(fermionic_transformation, solver)
result = gsc.solve(driver)
return result
def test_continuous_variable_decode(self):
"""Test decode func of IntegerToBinaryConverter for continuous variables"""
mdl = Model("test_continuous_varable_decode")
c = mdl.continuous_var(lb=0, ub=10.9, name="c")
x = mdl.binary_var(name="x")
mdl.maximize(c + x * x)
op = from_docplex_mp(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
new_x = converter.interpret(result.x)
self.assertEqual(new_x[0], 10.9)
def test_potential_interface(self):
"""Tests potential interface."""
seed = 50
algorithm_globals.random_seed = seed
stretch = partial(Molecule.absolute_distance, atom_pair=(1, 0))
# H-H molecule near equilibrium geometry
m = Molecule(
geometry=[
["H", [0.0, 0.0, 0.0]],
["H", [1.0, 0.0, 0.0]],
],
degrees_of_freedom=[stretch],
masses=[1.6735328e-27, 1.6735328e-27],
)
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper)
driver = PySCFDriver(molecule=m)
problem = ElectronicStructureProblem(driver)
solver = NumPyMinimumEigensolver()
me_gss = GroundStateEigensolver(converter, solver)
# Run BOPESSampler with exact eigensolution
points = np.arange(0.45, 5.3, 0.3)
sampler = BOPESSampler(gss=me_gss)
res = sampler.sample(problem, points)
# Testing Potential interface
pot = MorsePotential(m)
pot.fit(res.points, res.energies)
np.testing.assert_array_almost_equal([pot.alpha, pot.r_0],
[2.235, 0.720],
decimal=3)
np.testing.assert_array_almost_equal([pot.d_e, pot.m_shift],
[0.2107, -1.1419],
decimal=3)
def test_portfolio_diversification(self):
""" portfolio diversification test """
# Something of an integration test
# Solve the problem in a classical fashion via CPLEX and compare the solution
# Note that CPLEX uses a completely different integer linear programming formulation.
if not _HAS_CPLEX:
self.skipTest('CPLEX is not installed.')
x = None
classical_optimizer = ClassicalOptimizer(self.instance, self.n, self.q)
x, classical_cost = classical_optimizer.cplex_solution()
# Solve the problem using the exact eigensolver
result = NumPyMinimumEigensolver().compute_minimum_eigenvalue(
operator=self.qubit_op)
quantum_solution = get_portfoliodiversification_solution(
self.instance, self.n, self.q, result)
ground_level = get_portfoliodiversification_value(
self.instance, self.n, self.q, quantum_solution)
if x is not None:
np.testing.assert_approx_equal(ground_level, classical_cost)
np.testing.assert_array_almost_equal(quantum_solution, x, 5)
def test_converter_list(self):
"""Test converter list"""
op = QuadraticProgram()
op.integer_var(0, 3, "x")
op.binary_var('y')
op.maximize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={
'y': 1,
'x': 1
},
sense='LE',
rhs=3,
name='xy_leq')
# construct minimum eigen optimizer
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
# a single converter
qp2qubo = QuadraticProgramToQubo()
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=2, converters=qp2qubo)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
recursive_min_eigen_optimizer = RecursiveMinimumEigenOptimizer(
min_eigen_optimizer, min_num_vars=2, converters=converters)
result = recursive_min_eigen_optimizer.solve(op)
self.assertEqual(result.fval, 4)
# invalid converters
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
RecursiveMinimumEigenOptimizer(min_eigen_optimizer,
min_num_vars=2,
converters=invalid)
def test_cme_reuse(self):
"""Test reuse"""
# Start with no operator or aux_operators, give via compute method
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op)
self.assertEqual(result.eigenvalue.dtype, np.float64)
self.assertAlmostEqual(result.eigenvalue, -1.85727503)
self.assertIsNone(result.aux_operator_eigenvalues)
# Add aux_operators and go again
result = algo.compute_minimum_eigenvalue(
operator=self.qubit_op, aux_operators=self.aux_ops_list)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
# "Remove" aux_operators and go again
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=[])
self.assertEqual(result.eigenvalue.dtype, np.float64)
self.assertAlmostEqual(result.eigenvalue, -1.85727503)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set aux_operators and go again
result = algo.compute_minimum_eigenvalue(
operator=self.qubit_op, aux_operators=self.aux_ops_list)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
# Finally just set one of aux_operators and main operator, remove aux_operators
result = algo.compute_minimum_eigenvalue(operator=self.aux_ops_list[0],
aux_operators=[])
self.assertAlmostEqual(result.eigenvalue, 2 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
def test_continuous_variable_decode(self):
""" Test decode func of IntegerToBinaryConverter for continuous variables"""
try:
mdl = Model('test_continuous_varable_decode')
c = mdl.continuous_var(lb=0, ub=10.9, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
new_x = converter.interpret(result.x)
self.assertEqual(new_x[0], 10.9)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
def test_cme_reuse(self):
""" Test reuse """
# Start with no operator or aux_operators, give via compute method
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(self.qubit_op.to_opflow(), algo.operator)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set operator to None and go again
algo.operator = None
with self.assertRaises(AlgorithmError):
_ = algo.run()
# Set operator back as it was and go again
algo.operator = self.qubit_op
result = algo.compute_minimum_eigenvalue()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Add aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=self.aux_ops)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
# "Remove" aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=[])
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set aux_operators and go again
algo.aux_operators = self.aux_ops
result = algo.compute_minimum_eigenvalue()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
# Finally just set one of aux_operators and main operator, remove aux_operators
result = algo.compute_minimum_eigenvalue(self.aux_ops[0], [])
self.assertAlmostEqual(result.eigenvalue, 2 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
def supports_aux_operators(self):
return NumPyMinimumEigensolver.supports_aux_operators()
def test_cme_fail(self):
""" Test no operator """
algo = NumPyMinimumEigensolver()
with self.assertRaises(AlgorithmError):
_ = algo.run()
def test_samples(self):
"""Test samples"""
SUCCESS = OptimizationResultStatus.SUCCESS # pylint: disable=invalid-name
algorithm_globals.random_seed = 123
quantum_instance = QuantumInstance(backend=BasicAer.get_backend('qasm_simulator'),
seed_simulator=123, seed_transpiler=123,
shots=1000)
# test minimize
op = QuadraticProgram()
op.integer_var(0, 3, 'x')
op.binary_var('y')
op.minimize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={'x': 1, 'y': 1}, sense='>=', rhs=1, name='xy')
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(op)
opt_sol = 1
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [1, 0])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, SUCCESS)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x, [1, 0, 0, 0, 0])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, SUCCESS)
qaoa = QAOA(quantum_instance=quantum_instance)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(op)
self.assertEqual(len(result.samples), 8)
self.assertEqual(len(result.raw_samples), 32)
self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1)
self.assertAlmostEqual(min(s.fval for s in result.samples), 0)
self.assertAlmostEqual(min(s.fval for s in result.samples if s.status == SUCCESS), opt_sol)
self.assertAlmostEqual(min(s.fval for s in result.raw_samples), opt_sol)
for sample in result.raw_samples:
self.assertEqual(sample.status, SUCCESS)
np.testing.assert_array_almost_equal(result.x, result.samples[0].x)
self.assertAlmostEqual(result.fval, result.samples[0].fval)
self.assertEqual(result.status, result.samples[0].status)
# test maximize
op = QuadraticProgram()
op.integer_var(0, 3, 'x')
op.binary_var('y')
op.maximize(linear={'x': 1, 'y': 2})
op.linear_constraint(linear={'x': 1, 'y': 1}, sense='<=', rhs=1, name='xy')
min_eigen_solver = NumPyMinimumEigensolver()
min_eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver)
result = min_eigen_optimizer.solve(op)
opt_sol = 2
self.assertEqual(result.fval, opt_sol)
self.assertEqual(len(result.samples), 1)
np.testing.assert_array_almost_equal(result.samples[0].x, [0, 1])
self.assertAlmostEqual(result.samples[0].fval, opt_sol)
self.assertAlmostEqual(result.samples[0].probability, 1.0)
self.assertEqual(result.samples[0].status, SUCCESS)
self.assertEqual(len(result.raw_samples), 1)
np.testing.assert_array_almost_equal(result.raw_samples[0].x, [0, 0, 1, 0])
self.assertAlmostEqual(result.raw_samples[0].fval, opt_sol)
self.assertAlmostEqual(result.raw_samples[0].probability, 1.0)
self.assertEqual(result.raw_samples[0].status, SUCCESS)
qaoa = QAOA(quantum_instance=quantum_instance)
min_eigen_optimizer = MinimumEigenOptimizer(qaoa)
result = min_eigen_optimizer.solve(op)
self.assertEqual(len(result.samples), 8)
self.assertEqual(len(result.raw_samples), 16)
self.assertAlmostEqual(sum(s.probability for s in result.samples), 1)
self.assertAlmostEqual(sum(s.probability for s in result.raw_samples), 1)
self.assertAlmostEqual(max(s.fval for s in result.samples), 5)
self.assertAlmostEqual(max(s.fval for s in result.samples if s.status == SUCCESS), opt_sol)
self.assertAlmostEqual(max(s.fval for s in result.raw_samples), opt_sol)
for sample in result.raw_samples:
self.assertEqual(sample.status, SUCCESS)
np.testing.assert_array_almost_equal(result.x, result.samples[0].x)
self.assertAlmostEqual(result.fval, result.samples[0].fval)
self.assertEqual(result.status, result.samples[0].status)
