def test_quadratic_program_element_when_loaded_from_source(self): """Test QuadraticProgramElement when QuadraticProgram is loaded from an external source""" with self.subTest("from_ising"): q_p = QuadraticProgram() q_p.from_ising(PauliSumOp.from_list([("IZ", 1), ("ZZ", 2)])) self.assertEqual(id(q_p.objective.quadratic_program), id(q_p)) for elem in q_p.variables: self.assertEqual(id(elem.quadratic_program), id(q_p)) for elem in q_p.linear_constraints: self.assertEqual(id(elem.quadratic_program), id(q_p)) for elem in q_p.quadratic_constraints: self.assertEqual(id(elem.quadratic_program), id(q_p)) try: lp_file = self.get_resource_path("test_quadratic_program.lp", "problems/resources") q_p = QuadraticProgram() q_p.read_from_lp_file(lp_file) self.assertEqual(id(q_p.objective.quadratic_program), id(q_p)) for elem in q_p.variables: self.assertEqual(id(elem.quadratic_program), id(q_p)) for elem in q_p.linear_constraints: self.assertEqual(id(elem.quadratic_program), id(q_p)) for elem in q_p.quadratic_constraints: self.assertEqual(id(elem.quadratic_program), id(q_p)) except RuntimeError as ex: self.fail(str(ex))
def test_maximize_to_minimize(self): """Test maximization to minimization conversion""" op_max = QuadraticProgram() op_min = QuadraticProgram() for i in range(2): op_max.binary_var(name="x{}".format(i)) op_min.binary_var(name="x{}".format(i)) op_max.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3) op_min.integer_var(name="x{}".format(2), lowerbound=-3, upperbound=3) op_max.maximize(constant=3, linear={"x0": 1}, quadratic={("x1", "x2"): 2}) op_min.minimize(constant=3, linear={"x0": 1}, quadratic={("x1", "x2"): 2}) # check conversion of maximization problem conv = MaximizeToMinimize() op_conv = conv.convert(op_max) self.assertEqual(op_conv.objective.sense, op_conv.objective.Sense.MINIMIZE) x = [0, 1, 2] fval_min = op_conv.objective.evaluate(conv.interpret(x)) self.assertAlmostEqual(fval_min, -7) self.assertAlmostEqual(op_max.objective.evaluate(x), -fval_min) # check conversion of minimization problem op_conv = conv.convert(op_min) self.assertEqual(op_conv.objective.sense, op_min.objective.sense) fval_min = op_conv.objective.evaluate(conv.interpret(x)) self.assertAlmostEqual(op_min.objective.evaluate(x), fval_min)
def test_penalty_recalculation_when_reusing2(self): """Test the penalty retrieval and recalculation of LinearEqualityToPenalty 2""" 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") # First, create a converter with no penalty lineq2penalty = LinearEqualityToPenalty() self.assertIsNone(lineq2penalty.penalty) # Then converter must calculate the penalty for the problem (should be 4.0) lineq2penalty.convert(op) self.assertEqual(4, lineq2penalty.penalty) # Re-use the converter for a new problem op2 = QuadraticProgram() op2.binary_var("x") op2.minimize(linear={"x": 10}) op2.linear_constraint({"x": 1}, "==", 0) lineq2penalty.convert(op2) self.assertEqual(11, lineq2penalty.penalty)
def test_str_repr(self): """Test str and repr""" with self.subTest("5 variables"): n = 5 quadratic_program = QuadraticProgram() quadratic_program.binary_var_list(n) # x0,...,x4 expr = LinearExpression(quadratic_program, [float(e) for e in range(n)]) self.assertEqual(str(expr), "x1 + 2*x2 + 3*x3 + 4*x4") self.assertEqual(repr(expr), "<LinearExpression: x1 + 2*x2 + 3*x3 + 4*x4>") with self.subTest("50 variables"): # pylint: disable=cyclic-import from qiskit_optimization.translators.prettyprint import DEFAULT_TRUNCATE n = 50 quadratic_program = QuadraticProgram() quadratic_program.binary_var_list(n) # x0,...,x49 expr = LinearExpression(quadratic_program, [float(e) for e in range(n)]) expected = " ".join(["x1"] + sorted([f"+ {i}*x{i}" for i in range(2, n)], key=lambda e: e.split(" ")[1])) self.assertEqual(str(expr), expected) self.assertEqual( repr(expr), f"<LinearExpression: {expected[:DEFAULT_TRUNCATE]}...>")
def test_valid_variable_type(self): """Validate the types of the variables for QuadraticProgram.to_ising.""" # Integer variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.integer_var(0, 10, "int_var") _ = op.to_ising() # Continuous variable with self.assertRaises(QiskitOptimizationError): op = QuadraticProgram() op.continuous_var(0, 10, "continuous_var") _ = op.to_ising()
def test_linear_inequality_to_penalty4(self): """Test special constraint to penalty x1+x2+x3+... <= 1 -> P(x1*x2+x1*x3+...)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var(name="x") op.binary_var(name="y") op.binary_var(name="z") # Linear constraints linear_constraint = {"x": 1, "y": 1, "z": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(xy+yz+zx)") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) penalty = 1 quadratic = { ("x", "y"): penalty, ("x", "z"): penalty, ("y", "z"): penalty } op2 = lip.convert(op) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test maximize op = QuadraticProgram() op.binary_var_list(5) linear2 = [1, 1, 0, 0, 0] op.maximize(linear=linear2) op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.LE, 1, "") with self.subTest("Maximum"): self.assertEqual(op.get_num_linear_constraints(), 1) lip.penalty = 5 quadratic2 = [ [0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], ] op2 = lip.convert(op) ldct2 = op2.objective.linear.to_array() qdct2 = op2.objective.quadratic.to_array() / lip.penalty * -1 self.assertEqual(ldct2.tolist(), linear2) self.assertEqual(qdct2.tolist(), quadratic2) self.assertEqual(op2.get_num_linear_constraints(), 0)
def test_inequality_to_penalty_auto_define_penalty(self): """Test _auto_define_penalty() in InequalityToPenalty""" op = QuadraticProgram() op.integer_var(name="x", lowerbound=1, upperbound=3) op.integer_var(name="y", lowerbound=-1, upperbound=4) op.integer_var(name="z", lowerbound=-5, upperbound=-1) op.maximize(linear={"x": 1, "y": 1, "z": 1}) lip = LinearInequalityToPenalty() self.assertEqual(lip._auto_define_penalty(op), 12) op = QuadraticProgram() op.integer_var(name="x", lowerbound=1, upperbound=3) op.integer_var(name="y", lowerbound=-1, upperbound=4) op.integer_var(name="z", lowerbound=-5, upperbound=-1) op.maximize(linear={"x": -1, "y": -1, "z": -1}) lip = LinearInequalityToPenalty() self.assertEqual(lip._auto_define_penalty(op), 12) op = QuadraticProgram() op.integer_var(name="x", lowerbound=1, upperbound=3) op.integer_var(name="y", lowerbound=-1, upperbound=4) op.integer_var(name="z", lowerbound=-5, upperbound=-1) op.maximize(quadratic={ (0, 0): 1, (0, 1): 1, (0, 2): 1, (1, 1): 1, (1, 2): 1, (2, 2): 1 }) lip = LinearInequalityToPenalty() self.assertEqual(lip._auto_define_penalty(op), 103) op = QuadraticProgram() op.integer_var(name="x", lowerbound=1, upperbound=3) op.integer_var(name="y", lowerbound=-1, upperbound=4) op.integer_var(name="z", lowerbound=-5, upperbound=-1) op.maximize(quadratic={ (0, 0): -1, (0, 1): -1, (0, 2): -1, (1, 1): -1, (1, 2): -1, (2, 2): -1 }) lip = LinearInequalityToPenalty() self.assertEqual(lip._auto_define_penalty(op), 103) op = QuadraticProgram() op.integer_var(lowerbound=-2, upperbound=1, name="x") op.minimize(quadratic={("x", "x"): 1}) lip = LinearInequalityToPenalty() self.assertEqual(lip._auto_define_penalty(op), 5)
def test_name_setter(self): """ test name setter """ q_p = QuadraticProgram() self.assertEqual(q_p.name, '') name = 'test name' q_p.name = name self.assertEqual(q_p.name, name)
def test_setters(self): """ test setters. """ quadratic_program = QuadraticProgram() for _ in range(5): quadratic_program.continuous_var() n = quadratic_program.get_num_vars() zeros = np.zeros((n, n)) quadratic = QuadraticExpression(quadratic_program, zeros) coefficients_list = [[0 for _ in range(5)] for _ in range(5)] for i, v in enumerate(coefficients_list): for j, _ in enumerate(v): coefficients_list[min(i, j)][max(i, j)] += i * j coefficients_array = np.array(coefficients_list) coefficients_dok = dok_matrix(coefficients_list) coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()} coefficients_dict_str = {('x{}'.format(i), 'x{}'.format(j)): v for (i, j), v in coefficients_dok.items()} for coeffs in [coefficients_list, coefficients_array, coefficients_dok, coefficients_dict_int, coefficients_dict_str]: quadratic.coefficients = coeffs self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0) self.assertTrue((quadratic.to_array() == coefficients_list).all()) self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int) self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
def build_qubo_unconstrained_from_edges_dict(G, all_edges_dict, variables): qubo = QuadraticProgram() linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict) for var in variables: qubo.binary_var(var) qubo.minimize(linear=linear, quadratic=quadratic) return qubo, linear, quadratic
def test_feasibility(self): """Tests feasibility methods.""" q_p = QuadraticProgram("test") _ = q_p.continuous_var(-1, 1, "x") _ = q_p.continuous_var(-10, 10, "y") q_p.minimize(linear={"x": 1, "y": 1}) q_p.linear_constraint({"x": 1, "y": 1}, "<=", 10, "c0") q_p.linear_constraint({"x": 1, "y": 1}, ">=", -10, "c1") q_p.linear_constraint({"x": 1, "y": 1}, "==", 5, "c2") q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, "<=", 10, "c3") q_p.quadratic_constraint({"y": 1}, {("x", "x"): 1}, ">=", 5, "c4") q_p.quadratic_constraint(None, { ("x", "x"): 1, ("y", "y"): 1 }, "==", 25, "c5") self.assertTrue(q_p.is_feasible([0, 5])) self.assertFalse(q_p.is_feasible([1, 10])) self.assertFalse(q_p.is_feasible([1, -12])) self.assertFalse(q_p.is_feasible([1, 5])) self.assertFalse(q_p.is_feasible([5, 0])) self.assertFalse(q_p.is_feasible([1, 1])) self.assertFalse(q_p.is_feasible([0, 0])) feasible, variables, constraints = q_p.get_feasibility_info([10, 0]) self.assertFalse(feasible) self.assertIsNotNone(variables) self.assertEqual(1, len(variables)) self.assertEqual("x", variables[0].name) self.assertIsNotNone(constraints) self.assertEqual(3, len(constraints)) self.assertEqual("c2", constraints[0].name) self.assertEqual("c3", constraints[1].name) self.assertEqual("c5", constraints[2].name)
def test_objective_handling(self): """test objective handling""" q_p = QuadraticProgram() q_p.binary_var("x") q_p.binary_var("y") q_p.binary_var("z") q_p.minimize() obj = q_p.objective self.assertEqual(obj.sense, QuadraticObjective.Sense.MINIMIZE) self.assertEqual(obj.constant, 0) self.assertDictEqual(obj.linear.to_dict(), {}) self.assertDictEqual(obj.quadratic.to_dict(), {}) q_p.maximize(1, {"y": 1}, {("z", "x"): 1, ("y", "y"): 1}) obj = q_p.objective self.assertEqual(obj.sense, QuadraticObjective.Sense.MAXIMIZE) self.assertEqual(obj.constant, 1) self.assertDictEqual(obj.linear.to_dict(), {1: 1}) self.assertDictEqual(obj.linear.to_dict(use_name=True), {"y": 1}) self.assertListEqual(obj.linear.to_array().tolist(), [0, 1, 0]) self.assertDictEqual(obj.quadratic.to_dict(), {(0, 2): 1, (1, 1): 1}) self.assertDictEqual( obj.quadratic.to_dict(symmetric=True), {(0, 2): 0.5, (2, 0): 0.5, (1, 1): 1} ) self.assertDictEqual(obj.quadratic.to_dict(use_name=True), {("x", "z"): 1, ("y", "y"): 1}) self.assertDictEqual( obj.quadratic.to_dict(use_name=True, symmetric=True), {("x", "z"): 0.5, ("z", "x"): 0.5, ("y", "y"): 1}, ) self.assertListEqual(obj.quadratic.to_array().tolist(), [[0, 0, 1], [0, 1, 0], [0, 0, 0]]) self.assertListEqual( obj.quadratic.to_array(symmetric=True).tolist(), [[0, 0, 0.5], [0, 1, 0], [0.5, 0, 0]], )
def test_init(self): """test init.""" quadratic_program = QuadraticProgram() for _ in range(5): quadratic_program.continuous_var() coefficients_list = [[0 for _ in range(5)] for _ in range(5)] for i, v in enumerate(coefficients_list): for j, _ in enumerate(v): coefficients_list[min(i, j)][max(i, j)] += i * j coefficients_array = np.array(coefficients_list) coefficients_dok = dok_matrix(coefficients_list) coefficients_dict_int = {(i, j): v for (i, j), v in coefficients_dok.items()} coefficients_dict_str = {(f"x{i}", f"x{j}"): v for (i, j), v in coefficients_dok.items()} for coeffs in [ coefficients_list, coefficients_array, coefficients_dok, coefficients_dict_int, coefficients_dict_str, ]: quadratic = QuadraticExpression(quadratic_program, coeffs) self.assertEqual((quadratic.coefficients != coefficients_dok).nnz, 0) self.assertTrue((quadratic.to_array() == coefficients_list).all()) self.assertDictEqual(quadratic.to_dict(use_name=False), coefficients_dict_int) self.assertDictEqual(quadratic.to_dict(use_name=True), coefficients_dict_str)
def test_setters(self): """test setters.""" quadratic_program = QuadraticProgram() for _ in range(5): quadratic_program.continuous_var() zeros = np.zeros(quadratic_program.get_num_vars()) linear = LinearExpression(quadratic_program, zeros) coefficients_list = list(range(5)) coefficients_array = np.array(coefficients_list) coefficients_dok = dok_matrix([coefficients_list]) coefficients_dict_int = {i: i for i in range(1, 5)} coefficients_dict_str = {f"x{i}": i for i in range(1, 5)} for coeffs in [ coefficients_list, coefficients_array, coefficients_dok, coefficients_dict_int, coefficients_dict_str, ]: linear.coefficients = coeffs self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0) self.assertTrue((linear.to_array() == coefficients_list).all()) self.assertDictEqual(linear.to_dict(use_name=False), coefficients_dict_int) self.assertDictEqual(linear.to_dict(use_name=True), coefficients_dict_str)
def setUp(self): super().setUp() random.seed(123) low = 0 high = 100 pos = { i: (random.randint(low, high), random.randint(low, high)) for i in range(4) } self.graph = nx.random_geometric_graph( 4, np.hypot(high - low, high - low) + 1, pos=pos) for w, v in self.graph.edges: delta = [ self.graph.nodes[w]["pos"][i] - self.graph.nodes[v]["pos"][i] for i in range(2) ] self.graph.edges[w, v]["weight"] = np.rint( np.hypot(delta[0], delta[1])) op = QuadraticProgram() for i in range(16): op.binary_var() self.result = OptimizationResult( x=[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], fval=272, variables=op.variables, status=OptimizationResultStatus.SUCCESS, )
def test_simple_qubo(self): """Test on a simple QUBO problem.""" model = Model() # pylint:disable=invalid-name u = model.binary_var(name="u") v = model.binary_var(name="v") model.minimize((u - v + 2)**2) problem = QuadraticProgram() problem.from_docplex(model) backend = BasicAer.get_backend("statevector_simulator") qaoa = QAOA(quantum_instance=backend, reps=1) optimizer = WarmStartQAOAOptimizer( pre_solver=SlsqpOptimizer(), relax_for_pre_solver=True, qaoa=qaoa, epsilon=0.25, ) result_warm = optimizer.solve(problem) self.assertIsNotNone(result_warm) self.assertIsNotNone(result_warm.x) np.testing.assert_almost_equal([0, 1], result_warm.x, 3) self.assertIsNotNone(result_warm.fval) np.testing.assert_almost_equal(1, result_warm.fval, 3)
def test_quadratic_program_to_qubo_inequality_to_penalty(self): """Test QuadraticProgramToQubo, passing inequality pattern""" op = QuadraticProgram() conv = QuadraticProgramToQubo() op.binary_var(name="x") op.binary_var(name="y") # Linear constraints linear_constraint = {"x": 1, "y": 1} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 1, "P(1-x-y+xy)") conv.penalty = 1 constant = 1 linear = {"x": -conv.penalty, "y": -conv.penalty} quadratic = {("x", "y"): conv.penalty} op2 = conv.convert(op) cnst = op2.objective.constant ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(cnst, constant) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0)
def test_linear_inequality_to_penalty3(self): """Test special constraint to penalty x1+x2+x3+... >= n-1 -> P(x1*x2+x1*x3+...)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var_list(5) # Linear constraints n = 5 op.linear_constraint([1, 1, 1, 1, 1], Constraint.Sense.GE, n - 1, "") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) penalty = 5 lip.penalty = penalty constant = 10 linear = [n - 1, n - 1, n - 1, n - 1, n - 1] quadratic = [ [0, 1, 1, 1, 1], [0, 0, 1, 1, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], ] op2 = lip.convert(op) cnst2 = op2.objective.constant / penalty ldct2 = op2.objective.linear.to_array() / penalty * -1 qdct2 = op2.objective.quadratic.to_array() / penalty self.assertEqual(cnst2, constant) self.assertEqual(ldct2.tolist(), linear) self.assertEqual(qdct2.tolist(), quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0)
def qaoa(G): n = G.numberOfNodes() G = nw.nxadapter.nk2nx(G) w = nx.adjacency_matrix(G) problem = QuadraticProgram() _ = [problem.binary_var(f"x{i}") for i in range(n)] linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) c = [1] for _ in range(n - 1): c.append(0) problem.linear_constraint(c, '==', 1) cobyla = COBYLA() backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=cobyla, reps=3, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) L = result.x i = 0 res = {} for x in L: res[i] = x i += 1 return res
def test_constrained_binary(self): """Constrained binary optimization problem.""" model = Model() v = model.binary_var(name="v") w = model.binary_var(name="w") # pylint:disable=invalid-name t = model.binary_var(name="t") model.minimize(v + w + t) model.add_constraint(2 * v + 10 * w + t <= 3, "cons1") model.add_constraint(v + w + t >= 2, "cons2") problem = QuadraticProgram() problem.from_docplex(model) backend = BasicAer.get_backend("statevector_simulator") qaoa = QAOA(quantum_instance=backend, reps=1) aggregator = MeanAggregator() optimizer = WarmStartQAOAOptimizer( pre_solver=SlsqpOptimizer(), relax_for_pre_solver=True, qaoa=qaoa, epsilon=0.25, aggregator=aggregator, ) result_warm = optimizer.solve(problem) self.assertIsNotNone(result_warm) self.assertIsNotNone(result_warm.x) np.testing.assert_almost_equal([1, 0, 1], result_warm.x, 3) self.assertIsNotNone(result_warm.fval) np.testing.assert_almost_equal(2, result_warm.fval, 3)
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_integer_to_binary2(self): """Test integer to binary variables 2""" mod = QuadraticProgram() mod.integer_var(name="x", lowerbound=0, upperbound=1) mod.integer_var(name="y", lowerbound=0, upperbound=1) mod.minimize(1, {"x": 1}, {("x", "y"): 2}) mod.linear_constraint({"x": 1}, "==", 1) mod.quadratic_constraint({"x": 1}, {("x", "y"): 2}, "==", 1) mod2 = IntegerToBinary().convert(mod) self.assertListEqual([e.name + "@0" for e in mod.variables], [e.name for e in mod2.variables]) self.assertDictEqual(mod.objective.linear.to_dict(), mod2.objective.linear.to_dict()) self.assertDictEqual(mod.objective.quadratic.to_dict(), mod2.objective.quadratic.to_dict()) self.assertEqual(mod.get_num_linear_constraints(), mod2.get_num_linear_constraints()) for cst, cst2 in zip(mod.linear_constraints, mod2.linear_constraints): self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict()) self.assertEqual(mod.get_num_quadratic_constraints(), mod2.get_num_quadratic_constraints()) for cst, cst2 in zip(mod.quadratic_constraints, mod2.quadratic_constraints): self.assertDictEqual(cst.linear.to_dict(), cst2.linear.to_dict()) self.assertDictEqual(cst.quadratic.to_dict(), cst2.quadratic.to_dict())
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 test_ising_to_quadraticprogram_quadratic(self): """Test optimization problem to operators with linear=False""" op = QUBIT_OP_MAXIMIZE_SAMPLE offset = OFFSET_MAXIMIZE_SAMPLE quadratic = QuadraticProgram() quadratic.from_ising(op, offset, linear=False) self.assertEqual(quadratic.get_num_vars(), 4) self.assertEqual(quadratic.get_num_linear_constraints(), 0) self.assertEqual(quadratic.get_num_quadratic_constraints(), 0) self.assertEqual(quadratic.objective.sense, quadratic.objective.Sense.MINIMIZE) self.assertAlmostEqual(quadratic.objective.constant, 900000) quadratic_matrix = np.zeros((4, 4)) quadratic_matrix[0, 0] = -500001 quadratic_matrix[0, 1] = 400000 quadratic_matrix[0, 2] = 600000 quadratic_matrix[0, 3] = 800000 quadratic_matrix[1, 1] = -800001 quadratic_matrix[1, 2] = 1200000 quadratic_matrix[1, 3] = 1600000 quadratic_matrix[2, 2] = -900001 quadratic_matrix[2, 3] = 2400000 quadratic_matrix[3, 3] = -800001 np.testing.assert_array_almost_equal( quadratic.objective.quadratic.coefficients.toarray(), quadratic_matrix)
def test_init(self): """test init.""" quadratic_program = QuadraticProgram() for _ in range(5): quadratic_program.continuous_var() coefficients_list = list(range(5)) coefficients_array = np.array(coefficients_list) coefficients_dok = dok_matrix([coefficients_list]) coefficients_dict_int = {i: i for i in range(1, 5)} coefficients_dict_str = {"x{}".format(i): i for i in range(1, 5)} for coeffs in [ coefficients_list, coefficients_array, coefficients_dok, coefficients_dict_int, coefficients_dict_str, ]: linear = LinearExpression(quadratic_program, coeffs) self.assertEqual((linear.coefficients != coefficients_dok).nnz, 0) self.assertTrue((linear.to_array() == coefficients_list).all()) self.assertDictEqual(linear.to_dict(use_name=False), coefficients_dict_int) self.assertDictEqual(linear.to_dict(use_name=True), coefficients_dict_str)
def test_write_to_lp_file(self): """test write problem""" q_p = QuadraticProgram("my problem") q_p.binary_var("x") q_p.integer_var(-1, 5, "y") q_p.continuous_var(-1, 5, "z") q_p.minimize(1, {"x": 1, "y": -1, "z": 10}, {("x", "x"): 0.5, ("y", "z"): -1}) q_p.linear_constraint({"x": 1, "y": 2}, "==", 1, "lin_eq") q_p.linear_constraint({"x": 1, "y": 2}, "<=", 1, "lin_leq") q_p.linear_constraint({"x": 1, "y": 2}, ">=", 1, "lin_geq") q_p.quadratic_constraint( {"x": 1, "y": 1}, {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2}, "==", 1, "quad_eq", ) q_p.quadratic_constraint( {"x": 1, "y": 1}, {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2}, "<=", 1, "quad_leq", ) q_p.quadratic_constraint( {"x": 1, "y": 1}, {("x", "x"): 1, ("y", "z"): -1, ("z", "z"): 2}, ">=", 1, "quad_geq", ) reference_file_name = self.get_resource_path( "test_quadratic_program.lp", "problems/resources" ) with tempfile.TemporaryDirectory() as tmp: temp_output_path = path.join(tmp, "temp.lp") q_p.write_to_lp_file(temp_output_path) with open(reference_file_name, encoding="utf8") as reference, open( temp_output_path, encoding="utf8" ) as temp_output_file: lines1 = temp_output_file.readlines() lines2 = reference.readlines() self.assertListEqual(lines1, lines2) with tempfile.TemporaryDirectory() as temp_problem_dir: q_p.write_to_lp_file(temp_problem_dir) with open(path.join(temp_problem_dir, "my_problem.lp"), encoding="utf8") as file1, open( reference_file_name, encoding="utf8" ) as file2: lines1 = file1.readlines() lines2 = file2.readlines() self.assertListEqual(lines1, lines2) with self.assertRaises(OSError): q_p.write_to_lp_file("/cannot/write/this/file.lp") with self.assertRaises(DOcplexException): q_p.write_to_lp_file("")
def build_qubo_unconstrained_from_nodes(G, routes_dict): all_edges_dict = get_edges_dict(routes_dict) qubo = QuadraticProgram() linear, quadratic = get_linear_quadratic_coeffs(G, all_edges_dict) for var in routes_dict.keys(): qubo.binary_var(var) qubo.minimize(linear=linear, quadratic=quadratic) return qubo, linear, quadratic
def test_bounds(self): """test lowerbound and upperbound""" with self.subTest("bounded"): quadratic_program = QuadraticProgram() quadratic_program.continuous_var_list(3, lowerbound=-1, upperbound=2) coefficients_list = list(range(3)) bounds = LinearExpression(quadratic_program, coefficients_list).bounds self.assertAlmostEqual(bounds.lowerbound, -3) self.assertAlmostEqual(bounds.upperbound, 6) with self.subTest("bounded2"): quadratic_program = QuadraticProgram() quadratic_program.integer_var(lowerbound=-2, upperbound=-1, name="x") quadratic_program.integer_var(lowerbound=2, upperbound=4, name="y") bounds = LinearExpression(quadratic_program, {"x": 1, "y": 10}).bounds self.assertAlmostEqual(bounds.lowerbound, 18) self.assertAlmostEqual(bounds.upperbound, 39) bounds = LinearExpression(quadratic_program, {"x": -1, "y": 10}).bounds self.assertAlmostEqual(bounds.lowerbound, 21) self.assertAlmostEqual(bounds.upperbound, 42) bounds = LinearExpression(quadratic_program, {"x": 1, "y": -10}).bounds self.assertAlmostEqual(bounds.lowerbound, -42) self.assertAlmostEqual(bounds.upperbound, -21) bounds = LinearExpression(quadratic_program, {"x": -1, "y": -10}).bounds self.assertAlmostEqual(bounds.lowerbound, -39) self.assertAlmostEqual(bounds.upperbound, -18) bounds = LinearExpression(quadratic_program, {"x": 0, "y": 0}).bounds self.assertAlmostEqual(bounds.lowerbound, 0) self.assertAlmostEqual(bounds.upperbound, 0) with self.assertRaises(QiskitOptimizationError): quadratic_program = QuadraticProgram() quadratic_program.continuous_var_list(3, lowerbound=0, upperbound=INFINITY) coefficients_list = list(range(3)) _ = LinearExpression(quadratic_program, coefficients_list).bounds with self.assertRaises(QiskitOptimizationError): quadratic_program = QuadraticProgram() quadratic_program.continuous_var_list(3, lowerbound=-INFINITY, upperbound=0) coefficients_list = list(range(3)) _ = LinearExpression(quadratic_program, coefficients_list).bounds
def test_symmetric_set(self): """ test symmetric set """ q_p = QuadraticProgram() q_p.binary_var('x') q_p.binary_var('y') q_p.binary_var('z') quad = QuadraticExpression(q_p, {('x', 'y'): -1, ('y', 'x'): 2, ('z', 'x'): 3}) self.assertDictEqual(quad.to_dict(use_name=True), {('x', 'y'): 1, ('x', 'z'): 3}) self.assertDictEqual(quad.to_dict(symmetric=True, use_name=True), {('x', 'y'): 0.5, ('y', 'x'): 0.5, ('x', 'z'): 1.5, ('z', 'x'): 1.5})
def setUp(self): """Set up for the test""" super().setUp() self.num_set = [8, 7, 6, 5, 4] op = QuadraticProgram() for _ in range(5): op.binary_var() self.result = OptimizationResult( x=[1, 1, 0, 0, 0], fval=0, variables=op.variables, status=OptimizationResultStatus.SUCCESS)