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)