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_cme_aux_ops_dict(self): """Test dictionary compatibility of aux_operators""" # Start with an empty dictionary algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators={}) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) self.assertIsNone(result.aux_operator_eigenvalues) # Add aux_operators dictionary and go again result = algo.compute_minimum_eigenvalue( operator=self.qubit_op, aux_operators=self.aux_ops_dict) 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["aux_op1"], [2, 0]) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues["aux_op2"], [0, 0]) # Add None and zero operators and go again extra_ops = {"None_op": None, "zero_op": 0, **self.aux_ops_dict} 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), 3) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues["aux_op1"], [2, 0]) np.testing.assert_array_almost_equal( result.aux_operator_eigenvalues["aux_op2"], [0, 0]) self.assertEqual(result.aux_operator_eigenvalues["zero_op"], (0.0, 0))
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_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.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) 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) 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.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) 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) 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[0], aux_operators=[]) self.assertAlmostEqual(result.eigenvalue, 2 + 0j) self.assertIsNone(result.aux_operator_eigenvalues)
def test_aux_operators_dict(self): """Test dict-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_op1, "aux_op2": 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["aux_op1"][0], 2, places=6) self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0, places=6) # standard deviations self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][1], 0.0) self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][1], 0.0) # Go again with additional None and zero operators extra_ops = {**aux_ops, "None_operator": None, "zero_operator": 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), 3) # expectation values self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][0], 2, places=6) self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0, places=6) self.assertEqual(result.aux_operator_eigenvalues["zero_operator"][0], 0.0) self.assertTrue( "None_operator" not in result.aux_operator_eigenvalues.keys()) # standard deviations self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][1], 0.0) self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][1], 0.0) self.assertAlmostEqual( result.aux_operator_eigenvalues["zero_operator"][1], 0.0)
def test_docplex_constant_and_quadratic_terms_in_object_function(self): """ Docplex Constant and Quadratic terms in Object function test """ # Create an Ising Hamiltonian with docplex laplacian = np.array([[-3., 1., 1., 1.], [1., -2., 1., -0.], [1., 1., -3., 1.], [1., -0., 1., -2.]]) mdl = Model() # pylint: disable=unsubscriptable-object n = laplacian.shape[0] bias = [0] * 4 x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)} couplers_func = mdl.sum( 2 * laplacian[i, j] * (2 * x[i] - 1) * (2 * x[j] - 1) for i in range(n - 1) for j in range(i, n)) bias_func = mdl.sum(float(bias[i]) * x[i] for i in range(n)) ising_func = couplers_func + bias_func mdl.minimize(ising_func) qubit_op, offset = docplex.get_operator(mdl) e_e = NumPyMinimumEigensolver() result = e_e.compute_minimum_eigenvalue(operator=qubit_op) expected_result = -22 # Compare objective self.assertAlmostEqual(result.eigenvalue.real + offset, expected_result)
def test_partition(self): """ Partition test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) if x[0] != 0: x = np.logical_not(x) * 1 np.testing.assert_array_equal(x, [0, 1, 0])
def test_cme(self): """ Basic test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, 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])
def test_tsp(self): """ TSP test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op) x = sample_most_likely(result.eigenstate) # print(self.qubit_op.to_opflow().eval(result.eigenstate).adjoint().eval(result.eigenstate)) order = tsp.get_tsp_solution(x) np.testing.assert_equal(tsp.tsp_value(order, self.ins.w), tsp.tsp_value([1, 2, 0], self.ins.w))
def test_clique(self): """ Clique test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) ising_sol = clique.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1]) oracle = self._brute_force() self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k), oracle)
def test_portfolio(self): """ portfolio test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op) selection = OptimizationApplication.sample_most_likely( result.eigenstate) value = portfolio.portfolio_value(selection, self.muu, self.sigma, self.risk, self.budget, self.penalty) np.testing.assert_array_equal(selection, [0, 1, 1, 0]) self.assertAlmostEqual(value, -0.00679917)
def test_exact_cover(self): """ Exact Cover test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) ising_sol = exact_cover.get_solution(x) np.testing.assert_array_equal(ising_sol, [0, 1, 1, 0]) oracle = self._brute_force() self.assertEqual(exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets), oracle)
def test_vertex_cover(self): """ Vertex Cover test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) sol = vertex_cover.get_graph_solution(x) np.testing.assert_array_equal(sol, [0, 0, 1]) oracle = self._brute_force() self.assertEqual(np.count_nonzero(sol), oracle)
def test_set_packing(self): """ set packing test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) ising_sol = set_packing.get_solution(x) np.testing.assert_array_equal(ising_sol, [0, 1, 1]) oracle = self._brute_force() self.assertEqual(np.count_nonzero(ising_sol), oracle)
def _run_knapsack(values, weights, max_weight): qubit_op, _ = knapsack.get_operator(values, weights, max_weight) algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=qubit_op) x = sample_most_likely(result.eigenstate) solution = knapsack.get_solution(x, values) value, weight = knapsack.knapsack_value_weight(solution, values, weights) return solution, value, weight
def test_stable_set(self): """ Stable set test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) self.assertAlmostEqual(result.eigenvalue.real, -39.5) self.assertAlmostEqual(result.eigenvalue.real + self.offset, -38.0) ising_sol = stable_set.get_graph_solution(x) np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1]) self.assertEqual(stable_set.stable_set_value(x, self.w), (4, False))
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 test_cme_filter_empty(self): """ Test with filter always returning False """ # define filter criterion # pylint: disable=unused-argument def criterion(x, v, a_v): return False algo = NumPyMinimumEigensolver(filter_criterion=criterion) result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=self.aux_ops) self.assertEqual(result.eigenvalue, None) self.assertEqual(result.eigenstate, None) self.assertEqual(result.aux_operator_eigenvalues, None)
def test_graph_partition(self): """ Graph Partition test """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) x = sample_most_likely(result.eigenstate) # check against the oracle ising_sol = graph_partition.get_graph_solution(x) # solutions are equivalent self.assertEqual( graph_partition.objective_value(np.array([0, 1, 0, 1]), self.w), graph_partition.objective_value(ising_sol, self.w)) oracle = self._brute_force() self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_cme_filter(self): """ Basic test """ # define filter criterion # pylint: disable=unused-argument def criterion(x, v, a_v): return v >= -0.5 algo = NumPyMinimumEigensolver(filter_criterion=criterion) result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=self.aux_ops) self.assertAlmostEqual(result.eigenvalue, -0.22491125 + 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])
def test_docplex_integer_constraints(self): """ Docplex Integer Constraints test """ # Create an Ising Hamiltonian with docplex mdl = Model(name='integer_constraints') x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(1, 5)} max_vars_func = mdl.sum(x[i] for i in range(1, 5)) mdl.maximize(max_vars_func) mdl.add_constraint(mdl.sum(i * x[i] for i in range(1, 5)) == 3) qubit_op, offset = docplex.get_operator(mdl) e_e = NumPyMinimumEigensolver() result = e_e.compute_minimum_eigenvalue(operator=qubit_op) expected_result = -2 # Compare objective self.assertAlmostEqual(result.eigenvalue.real + offset, expected_result)
def test_constants_in_left_side_and_variables_in_right_side(self): """ Test Constant values on the left-hand side of constraints and variables on the right-hand side of constraints for the DOcplex translator""" mdl = Model('left_constants_and_right_variables') x = mdl.binary_var(name='x') y = mdl.binary_var(name='y') mdl.maximize(mdl.sum(x + y)) mdl.add_constraint(x == y) qubit_op, offset = docplex.get_operator(mdl) self.log.debug(qubit_op) e_e = NumPyMinimumEigensolver() result = e_e.compute_minimum_eigenvalue(operator=qubit_op) self.assertEqual(result.eigenvalue.real + offset, -2) actual_sol = result.eigenstate.to_matrix().tolist() self.assertListEqual(actual_sol, [0, 0, 0, 1])
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 test_cme_1q(self, op): """ Test for 1 qubit operator """ algo = NumPyMinimumEigensolver() result = algo.compute_minimum_eigenvalue(operator=op) self.assertAlmostEqual(result.eigenvalue, -1)