def test_penalize_binary(self): """ Test PenalizeLinearEqualityConstraints with binary variables """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {'x0': 1, 'x1': 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {'x1': 1, 'x2': -1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x1x2') linear_constraint = {'x0': 1, 'x2': 3} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x0x2') self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() op2 = conv.convert(op) self.assertEqual(op2.get_num_linear_constraints(), 0) result = OptimizationResult(x=np.arange(3), fval=0, variables=op2.variables) new_result = conv.interpret(result) self.assertEqual(new_result.status, OptimizationResultStatus.INFEASIBLE) np.testing.assert_array_almost_equal(new_result.x, np.arange(3)) self.assertListEqual(result.variable_names, ['x0', 'x1', 'x2']) self.assertDictEqual(result.variables_dict, { 'x0': 0, 'x1': 1, 'x2': 2 })
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_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {'x0': 1, 'x1': 2, 'x2': 1} op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() op2 = conv.convert(op) result = OptimizationResult(x=[0, 1, 1, 1, 1], fval=17, variables=op2.variables) new_result = conv.interpret(result) np.testing.assert_array_almost_equal(new_result.x, [0, 1, 5]) self.assertEqual(new_result.fval, 17) self.assertListEqual(new_result.variable_names, ['x0', 'x1', 'x2']) self.assertDictEqual(new_result.variables_dict, { 'x0': 0, 'x1': 1, 'x2': 5 })
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_optimizationproblem_to_ising_deprecated(self): """ Test optimization problem to operators""" op = QuadraticProgram() for i in range(4): op.binary_var(name='x{}'.format(i)) linear = {} for x in op.variables: linear[x.name] = 1 op.maximize(0, linear, {}) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.linear_constraint(linear, Constraint.Sense.EQ, 3, 'sum1') penalize = LinearEqualityToPenalty(penalty=1e5) try: warnings.filterwarnings(action="ignore", category=DeprecationWarning) op2 = penalize.encode(op) conv = QuadraticProgramToIsing() qubitop, offset = conv.encode(op2) finally: warnings.filterwarnings(action="always", category=DeprecationWarning) self.assertEqual(qubitop, QUBIT_OP_MAXIMIZE_SAMPLE) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE)
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) decoded_result = lineq2penalty.interpret(result) self.assertEqual(decoded_result.fval, 4) np.testing.assert_array_almost_equal(decoded_result.x, [1, 1, 0]) self.assertEqual(decoded_result.status, OptimizationResultStatus.SUCCESS) self.assertListEqual(decoded_result.variable_names, ['x', 'y', 'z']) self.assertDictEqual(decoded_result.variables_dict, {'x': 1.0, 'y': 1.0, 'z': 0.0}) infeasible_result = OptimizationResult(x=[1, 1, 1], fval=0, variables=qprog.variables, status=OptimizationResultStatus.SUCCESS) decoded_infeasible_result = lineq2penalty.interpret(infeasible_result) self.assertEqual(decoded_infeasible_result.fval, 5) np.testing.assert_array_almost_equal(decoded_infeasible_result.x, [1, 1, 1]) self.assertEqual(decoded_infeasible_result.status, OptimizationResultStatus.INFEASIBLE) self.assertListEqual(infeasible_result.variable_names, ['x', 'y', 'z']) self.assertDictEqual(infeasible_result.variables_dict, {'x': 1.0, 'y': 1.0, 'z': 1.0})
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_optimizationproblem_to_ising(self): """ Test optimization problem to operators""" op = QuadraticProgram() for i in range(4): op.binary_var(name='x{}'.format(i)) linear = {} for x in op.variables: linear[x.name] = 1 op.maximize(0, linear, {}) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.linear_constraint(linear, Constraint.Sense.EQ, 3, 'sum1') penalize = LinearEqualityToPenalty() op2ope = QuadraticProgramToIsing() op2 = penalize.encode(op) qubitop, offset = op2ope.encode(op2) # the encoder uses a dictionary, in which the order of items in Python 3.5 is not # maintained, therefore don't do a list compare but dictionary compare qubit_op_as_dict = dict(qubitop.paulis) for coeff, paulis in QUBIT_OP_MAXIMIZE_SAMPLE.paulis: self.assertEqual(paulis, qubit_op_as_dict[coeff]) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE)
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 test_inequality_mode_auto(self): """ Test auto mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {'x0': 1, 'x1': 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {'x1': 1, 'x2': -1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {'x0': 1.1, 'x2': 2.2} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 3.3, 'x0x2') conv = InequalityToEquality(mode='auto') op2 = conv.convert(op) lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.INTEGER, Variable.Type.CONTINUOUS])
def test_penalize_sense(self): """ Test PenalizeLinearEqualityConstraints with senses """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {'x0': 1, 'x1': 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {'x1': 1, 'x2': -1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {'x0': 1, 'x2': 3} op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() with self.assertRaises(QiskitOptimizationError): conv.convert(op)
def test_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {'x0': 1, 'x1': 2, 'x2': 1} op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() _ = conv.convert(op) new_x = conv.interpret([0, 1, 1, 1, 1]) np.testing.assert_array_almost_equal(new_x, [0, 1, 5])
def _test_readme_sample(self): """ readme sample test """ # pylint: disable=import-outside-toplevel,redefined-builtin def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # Fix the random seed of SPSA (Optional) from qiskit.aqua import aqua_globals aqua_globals.random_seed = 123 # --- Exact copy of sample code ---------------------------------------- import networkx as nx import numpy as np from qiskit.optimization import QuadraticProgram from qiskit.optimization.algorithms import MinimumEigenOptimizer from qiskit import BasicAer from qiskit.aqua.algorithms import QAOA from qiskit.aqua.components.optimizers import SPSA # Generate a graph of 4 nodes n = 4 graph = nx.Graph() graph.add_nodes_from(np.arange(0, n, 1)) elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)] graph.add_weighted_edges_from(elist) # Compute the weight matrix from the graph w = nx.adjacency_matrix(graph) # Formulate the problem as quadratic program problem = QuadraticProgram() _ = [problem.binary_var('x{}'.format(i)) for i in range(n)] # create n binary variables linear = w.dot(np.ones(n)) quadratic = -w problem.maximize(linear=linear, quadratic=quadratic) # Fix node 0 to be 1 to break the symmetry of the max-cut solution problem.linear_constraint([1, 0, 0, 0], '==', 1) # Run quantum algorithm QAOA on qasm simulator spsa = SPSA(maxiter=250) backend = BasicAer.get_backend('qasm_simulator') qaoa = QAOA(optimizer=spsa, p=5, quantum_instance=backend) algorithm = MinimumEigenOptimizer(qaoa) result = algorithm.solve(problem) print(result) # prints solution, x=[1, 0, 1, 0], the cost, fval=4 # ---------------------------------------------------------------------- np.testing.assert_array_almost_equal(result.x, [1, 0, 1, 0]) self.assertAlmostEqual(result.fval, 4.0)
def test_clear(self): """ test clear """ q_p = QuadraticProgram('test') q_p.binary_var('x') q_p.binary_var('y') q_p.minimize(constant=1, linear={'x': 1, 'y': 2}, quadratic={('x', 'x'): 1}) q_p.linear_constraint({'x': 1}, '==', 1) q_p.quadratic_constraint({'x': 1}, {('y', 'y'): 2}, '<=', 1) q_p.clear() self.assertEqual(q_p.name, '') self.assertEqual(q_p.status, QuadraticProgram.Status.VALID) self.assertEqual(q_p.get_num_vars(), 0) self.assertEqual(q_p.get_num_linear_constraints(), 0) self.assertEqual(q_p.get_num_quadratic_constraints(), 0) self.assertEqual(q_p.objective.constant, 0) self.assertDictEqual(q_p.objective.linear.to_dict(), {}) self.assertDictEqual(q_p.objective.quadratic.to_dict(), {})
def test_integer_to_binary(self): """ Test integer to binary """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.maximize(0, linear, {}) conv = IntegerToBinary() op2 = conv.encode(op) for x in op2.variables: self.assertEqual(x.vartype, Variable.Type.BINARY) dct = op2.objective.linear.to_dict() self.assertEqual(dct[2], 3) self.assertEqual(dct[3], 6) self.assertEqual(dct[4], 6)
def test_optimizationproblem_to_ising(self): """ Test optimization problem to operators""" op = QuadraticProgram() for i in range(4): op.binary_var(name='x{}'.format(i)) linear = {} for x in op.variables: linear[x.name] = 1 op.maximize(0, linear, {}) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.linear_constraint(linear, Constraint.Sense.EQ, 3, 'sum1') penalize = LinearEqualityToPenalty(penalty=1e5) op2 = penalize.convert(op) qubitop, offset = op2.to_ising() self.assertEqual(qubitop, QUBIT_OP_MAXIMIZE_SAMPLE) self.assertEqual(offset, OFFSET_MAXIMIZE_SAMPLE)
def test_auto_penalty_warning(self): """ Test warnings of auto penalty function""" op = QuadraticProgram() op.binary_var('x') op.binary_var('y') op.binary_var('z') op.minimize(linear={'x': 1, 'y': 2}) op.linear_constraint(linear={'x': 0.5, 'y': 0.5, 'z': 0.5}, sense='EQ', rhs=1, name='xyz') with self.assertLogs('qiskit.optimization', level='WARNING') as log: lineq2penalty = LinearEqualityToPenalty() _ = lineq2penalty.encode(op) warning = ( 'WARNING:qiskit.optimization.converters.linear_equality_to_penalty:' + 'Warning: Using 100000.000000 for the penalty coefficient because a float ' + 'coefficient exists in constraints. \nThe value could be too small. If so, ' + 'set the penalty coefficient manually.' ) self.assertIn(warning, log.output)
def test_integer_to_binary(self): """ Test integer to binary """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {} for i, x in enumerate(op.variables): linear[x.name] = i + 1 op.maximize(0, linear, {}) conv = IntegerToBinary() op2 = conv.convert(op) self.assertEqual(op2.get_num_vars(), 5) self.assertListEqual([x.vartype for x in op2.variables], [Variable.Type.BINARY] * 5) self.assertListEqual([x.name for x in op2.variables], ['x0', 'x1', 'x2@0', 'x2@1', 'x2@2']) dct = op2.objective.linear.to_dict() self.assertEqual(dct[2], 3) self.assertEqual(dct[3], 6) self.assertEqual(dct[4], 6)
def test_penalize_binary(self): """ Test PenalizeLinearEqualityConstraints with binary variables """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {'x0': 1, 'x1': 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {'x1': 1, 'x2': -1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x1x2') linear_constraint = {'x0': 1, 'x2': 3} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x0x2') self.assertEqual(op.get_num_linear_constraints(), 3) conv = LinearEqualityToPenalty() op2 = conv.convert(op) self.assertEqual(op2.get_num_linear_constraints(), 0) new_x = conv.interpret(np.arange(3)) np.testing.assert_array_almost_equal(new_x, np.arange(3))
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(path.join('resources', 'test_quadratic_program.lp')) temp_output_file = tempfile.NamedTemporaryFile(mode='w+t', suffix='.lp') q_p.write_to_lp_file(temp_output_file.name) with open(reference_file_name) as reference: lines1 = temp_output_file.readlines() lines2 = reference.readlines() self.assertListEqual(lines1, lines2) temp_output_file.close() # automatically deleted 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')) as file1, open( reference_file_name) 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 test_binary_to_integer(self): """ Test binary to integer """ op = QuadraticProgram() for i in range(0, 2): op.binary_var(name='x{}'.format(i)) op.integer_var(name='x2', lowerbound=0, upperbound=5) linear = {} linear['x0'] = 1 linear['x1'] = 2 linear['x2'] = 1 op.maximize(0, linear, {}) linear = {} for x in op.variables: linear[x.name] = 1 op.linear_constraint(linear, Constraint.Sense.EQ, 6, 'x0x1x2') conv = IntegerToBinary() _ = conv.encode(op) result = OptimizationResult(x=[0, 1, 1, 1, 1], fval=17) new_result = conv.decode(result) self.assertListEqual(new_result.x, [0, 1, 5]) self.assertEqual(new_result.fval, 17)
def test_penalize_binary(self): """ Test PenalizeLinearEqualityConstraints with binary variables """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 2, 'x0x2') self.assertEqual(len(op.linear_constraints), 3) conv = LinearEqualityToPenalty() op2 = conv.encode(op) self.assertEqual(len(op2.linear_constraints), 0)
def test_inequality_mode_integer(self): """ Test integer mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') conv = InequalityToEquality(mode='integer') op2 = conv.convert(op) lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.INTEGER, Variable.Type.INTEGER])
def test_penalize_sense(self): """ Test PenalizeLinearEqualityConstraints with senses """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') self.assertEqual(len(op.linear_constraints), 3) conv = LinearEqualityToPenalty() with self.assertRaises(QiskitOptimizationError): conv.encode(op)
def test_inequality_mode_continuous(self): """ Test continuous mode of InequalityToEqualityConverter() """ op = QuadraticProgram() for i in range(3): op.binary_var(name='x{}'.format(i)) # Linear constraints linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x1'] = 1 op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, 'x0x1') linear_constraint = {} linear_constraint['x1'] = 1 linear_constraint['x2'] = -1 op.linear_constraint(linear_constraint, Constraint.Sense.LE, 2, 'x1x2') linear_constraint = {} linear_constraint['x0'] = 1 linear_constraint['x2'] = 3 op.linear_constraint(linear_constraint, Constraint.Sense.GE, 2, 'x0x2') conv = InequalityToEquality() op2 = conv.encode(op, mode='continuous') lst = [op2.variables[3].vartype, op2.variables[4].vartype] self.assertListEqual(lst, [Variable.Type.CONTINUOUS, Variable.Type.CONTINUOUS])
def test_0var_range_inequality(self): """ Test InequalityToEquality converter when the var_rang of the slack variable is 0""" op = QuadraticProgram() op.binary_var('x') op.binary_var('y') op.linear_constraint(linear={ 'x': 1, 'y': 1 }, sense='LE', rhs=0, name='xy_leq1') op.linear_constraint(linear={ 'x': 1, 'y': 1 }, sense='GE', rhs=2, name='xy_geq1') op.quadratic_constraint(quadratic={('x', 'x'): 1}, sense='LE', rhs=0, name='xy_leq2') op.quadratic_constraint(quadratic={('x', 'y'): 1}, sense='GE', rhs=1, name='xy_geq2') ineq2eq = InequalityToEquality() new_op = ineq2eq.convert(op) self.assertEqual(new_op.get_num_vars(), 2) self.assertTrue( all(l_const.sense == Constraint.Sense.EQ for l_const in new_op.linear_constraints)) self.assertTrue( all(q_const.sense == Constraint.Sense.EQ for q_const in new_op.quadratic_constraints))
from qiskit.optimization import QuadraticProgram from qiskit.optimization.algorithms import MinimumEigenOptimizer from dwave.plugins.qiskit import DWaveMinimumEigensolver # Specify the problem - in IBM language qp = QuadraticProgram() qp.binary_var('x') qp.binary_var('y') qp.binary_var('z') g = 25 qp.minimize(linear={'x': 17 - 3*g, 'y': 21 - 3*g, 'z': 19 - 3*g}, quadratic={'zx': g*2, 'yx': g*2, 'zy': g*2}) dwave_mes = DWaveMinimumEigensolver() optimizer = MinimumEigenOptimizer(dwave_mes) result = optimizer.solve(qp) print(result.samples)
def test_substitute_variables(self): """test substitute variables""" q_p = QuadraticProgram('test') q_p.binary_var(name='x') q_p.integer_var(name='y', lowerbound=-2, upperbound=4) q_p.continuous_var(name='z', lowerbound=-1.5, upperbound=3.2) q_p.minimize(constant=1, linear={ 'x': 1, 'y': 2 }, quadratic={ ('x', 'y'): -1, ('z', 'z'): 2 }) q_p.linear_constraint({'x': 2, 'z': -1}, '==', 1) q_p.quadratic_constraint({'x': 2, 'z': -1}, {('y', 'z'): 3}, '<=', -1) q_p2 = q_p.substitute_variables(constants={'x': -1}) self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE) q_p2 = q_p.substitute_variables(constants={'y': -3}) self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE) q_p2 = q_p.substitute_variables(constants={'x': 1, 'z': 2}) self.assertEqual(q_p2.status, QuadraticProgram.Status.INFEASIBLE) q_p2.clear() self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID) q_p2 = q_p.substitute_variables(constants={'x': 0}) self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID) self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {'y': 2}) self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), {('z', 'z'): 2}) self.assertEqual(q_p2.objective.constant, 1) self.assertEqual(len(q_p2.linear_constraints), 1) self.assertEqual(len(q_p2.quadratic_constraints), 1) cst = q_p2.linear_constraints[0] self.assertDictEqual(cst.linear.to_dict(use_name=True), {'z': -1}) self.assertEqual(cst.sense.name, 'EQ') self.assertEqual(cst.rhs, 1) cst = q_p2.quadratic_constraints[0] self.assertDictEqual(cst.linear.to_dict(use_name=True), {'z': -1}) self.assertDictEqual(cst.quadratic.to_dict(use_name=True), {('y', 'z'): 3}) self.assertEqual(cst.sense.name, 'LE') self.assertEqual(cst.rhs, -1) q_p2 = q_p.substitute_variables(constants={'z': -1}) self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID) self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), { 'x': 1, 'y': 2 }) self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), {('x', 'y'): -1}) self.assertEqual(q_p2.objective.constant, 3) self.assertEqual(len(q_p2.linear_constraints), 2) self.assertEqual(len(q_p2.quadratic_constraints), 0) cst = q_p2.linear_constraints[0] self.assertDictEqual(cst.linear.to_dict(use_name=True), {'x': 2}) self.assertEqual(cst.sense.name, 'EQ') self.assertEqual(cst.rhs, 0) cst = q_p2.linear_constraints[1] self.assertDictEqual(cst.linear.to_dict(use_name=True), { 'x': 2, 'y': -3 }) self.assertEqual(cst.sense.name, 'LE') self.assertEqual(cst.rhs, -2) q_p2 = q_p.substitute_variables(variables={'y': ('x', -0.5)}) self.assertEqual(q_p2.status, QuadraticProgram.Status.VALID) self.assertDictEqual(q_p2.objective.linear.to_dict(use_name=True), {}) self.assertDictEqual(q_p2.objective.quadratic.to_dict(use_name=True), { ('x', 'x'): 0.5, ('z', 'z'): 2 }) self.assertEqual(q_p2.objective.constant, 1) self.assertEqual(len(q_p2.linear_constraints), 1) self.assertEqual(len(q_p2.quadratic_constraints), 1) cst = q_p2.linear_constraints[0] self.assertDictEqual(cst.linear.to_dict(use_name=True), { 'x': 2, 'z': -1 }) self.assertEqual(cst.sense.name, 'EQ') self.assertEqual(cst.rhs, 1) cst = q_p2.quadratic_constraints[0] self.assertDictEqual(cst.linear.to_dict(use_name=True), { 'x': 2, 'z': -1 }) self.assertDictEqual(cst.quadratic.to_dict(use_name=True), {('x', 'z'): -1.5}) self.assertEqual(cst.sense.name, 'LE') self.assertEqual(cst.rhs, -1)
def test_docplex(self): """test from_docplex and to_docplex""" q_p = QuadraticProgram('test') q_p.binary_var(name='x') q_p.integer_var(name='y', lowerbound=-2, upperbound=4) q_p.continuous_var(name='z', lowerbound=-1.5, upperbound=3.2) q_p.minimize(constant=1, linear={ 'x': 1, 'y': 2 }, quadratic={ ('x', 'y'): -1, ('z', 'z'): 2 }) q_p.linear_constraint({'x': 2, 'z': -1}, '==', 1) q_p.quadratic_constraint({'x': 2, 'z': -1}, {('y', 'z'): 3}, '==', 1) q_p2 = QuadraticProgram() q_p2.from_docplex(q_p.to_docplex()) self.assertEqual(q_p.export_as_lp_string(), q_p2.export_as_lp_string()) mod = Model('test') x = mod.binary_var('x') y = mod.integer_var(-2, 4, 'y') z = mod.continuous_var(-1.5, 3.2, 'z') mod.minimize(1 + x + 2 * y - x * y + 2 * z * z) mod.add(2 * x - z == 1, 'c0') mod.add(2 * x - z + 3 * y * z == 1, 'q0') self.assertEqual(q_p.export_as_lp_string(), mod.export_as_lp_string()) with self.assertRaises(QiskitOptimizationError): mod = Model() mod.semiinteger_var(lb=1, name='x') q_p.from_docplex(mod) with self.assertRaises(QiskitOptimizationError): mod = Model() x = mod.binary_var('x') mod.add_range(0, 2 * x, 1) q_p.from_docplex(mod) with self.assertRaises(QiskitOptimizationError): mod = Model() x = mod.binary_var('x') y = mod.binary_var('y') mod.add_indicator(x, x + y <= 1, 1) q_p.from_docplex(mod) with self.assertRaises(QiskitOptimizationError): mod = Model() x = mod.binary_var('x') y = mod.binary_var('y') mod.add_equivalence(x, x + y <= 1, 1) q_p.from_docplex(mod) with self.assertRaises(QiskitOptimizationError): mod = Model() x = mod.binary_var('x') y = mod.binary_var('y') mod.add(mod.not_equal_constraint(x, y + 1)) q_p.from_docplex(mod) # test from_docplex without explicit variable names mod = Model() x = mod.binary_var() y = mod.continuous_var() z = mod.integer_var() mod.minimize(x + y + z + x * y + y * z + x * z) mod.add_constraint(x + y == z) # linear EQ mod.add_constraint(x + y >= z) # linear GE mod.add_constraint(x + y <= z) # linear LE mod.add_constraint(x * y == z) # quadratic EQ mod.add_constraint(x * y >= z) # quadratic GE mod.add_constraint(x * y <= z) # quadratic LE q_p = QuadraticProgram() q_p.from_docplex(mod) var_names = [v.name for v in q_p.variables] self.assertListEqual(var_names, ['x0', 'x1', 'x2']) senses = [ Constraint.Sense.EQ, Constraint.Sense.GE, Constraint.Sense.LE ] for i, c in enumerate(q_p.linear_constraints): self.assertDictEqual(c.linear.to_dict(use_name=True), { 'x0': 1, 'x1': 1, 'x2': -1 }) self.assertEqual(c.rhs, 0) self.assertEqual(c.sense, senses[i]) for i, c in enumerate(q_p.quadratic_constraints): self.assertEqual(c.rhs, 0) self.assertDictEqual(c.linear.to_dict(use_name=True), {'x2': -1}) self.assertDictEqual(c.quadratic.to_dict(use_name=True), {('x0', 'x1'): 1}) self.assertEqual(c.sense, senses[i])
def test_var_dict(self): """test {binary,integer,continuous}_var_dict""" q_p = QuadraticProgram() d_0 = q_p.continuous_var_dict(name='a', key_format='_{}', keys=3) self.assertSetEqual(set(d_0.keys()), {'a_0', 'a_1', 'a_2'}) self.assertSetEqual({var.name for var in q_p.variables}, {'a_0', 'a_1', 'a_2'}) for var in q_p.variables: self.assertAlmostEqual(var.lowerbound, 0) self.assertAlmostEqual(var.upperbound, INFINITY) self.assertEqual(var.vartype, VarType.CONTINUOUS) self.assertTupleEqual(var.as_tuple(), d_0[var.name].as_tuple()) d_1 = q_p.binary_var_dict(name='b', keys=5) self.assertSetEqual(set(d_1.keys()), {'b3', 'b4', 'b5', 'b6', 'b7'}) self.assertSetEqual( {var.name for var in q_p.variables}, {'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7'}) for var in q_p.variables[-5:]: self.assertAlmostEqual(var.lowerbound, 0) self.assertAlmostEqual(var.upperbound, 1) self.assertEqual(var.vartype, VarType.BINARY) self.assertTupleEqual(var.as_tuple(), d_1[var.name].as_tuple()) d_2 = q_p.integer_var_dict(keys=1, key_format='-{}', lowerbound=-4, upperbound=10) self.assertSetEqual(set(d_2.keys()), {'x-8'}) self.assertSetEqual( {var.name for var in q_p.variables}, {'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7', 'x-8'}) for var in q_p.variables[-1:]: self.assertAlmostEqual(var.lowerbound, -4) self.assertAlmostEqual(var.upperbound, 10) self.assertEqual(var.vartype, VarType.INTEGER) self.assertTupleEqual(var.as_tuple(), d_2[var.name].as_tuple()) d_3 = q_p.binary_var_dict(name='c', keys=range(3)) self.assertSetEqual(set(d_3.keys()), {'c0', 'c1', 'c2'}) self.assertSetEqual({var.name for var in q_p.variables}, { 'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7', 'x-8', 'c0', 'c1', 'c2' }) for var in q_p.variables[-3:]: self.assertAlmostEqual(var.lowerbound, 0) self.assertAlmostEqual(var.upperbound, 1) self.assertEqual(var.vartype, VarType.BINARY) self.assertTupleEqual(var.as_tuple(), d_3[var.name].as_tuple()) with self.assertRaises(QiskitOptimizationError): q_p.binary_var_dict(name='c', keys=range(3)) d_4 = q_p.binary_var_dict(1, 'x', '_') self.assertSetEqual(set(d_4.keys()), {'x_'}) self.assertSetEqual({var.name for var in q_p.variables}, { 'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7', 'x-8', 'c0', 'c1', 'c2', 'x_' }) for var in q_p.variables[-1:]: self.assertAlmostEqual(var.lowerbound, 0) self.assertAlmostEqual(var.upperbound, 1) self.assertEqual(var.vartype, VarType.BINARY) self.assertTupleEqual(var.as_tuple(), d_4[var.name].as_tuple()) with self.assertRaises(QiskitOptimizationError): q_p.binary_var_dict(1, 'x', '_') with self.assertRaises(QiskitOptimizationError): q_p.binary_var('x_') d_5 = q_p.continuous_var_dict(1, -1, 2, '', '') self.assertSetEqual(set(d_5.keys()), {''}) self.assertSetEqual({var.name for var in q_p.variables}, { 'a_0', 'a_1', 'a_2', 'b3', 'b4', 'b5', 'b6', 'b7', 'x-8', 'c0', 'c1', 'c2', 'x_', '' }) for var in q_p.variables[-1:]: self.assertAlmostEqual(var.lowerbound, -1) self.assertAlmostEqual(var.upperbound, 2) self.assertEqual(var.vartype, VarType.CONTINUOUS) self.assertTupleEqual(var.as_tuple(), d_5[var.name].as_tuple()) with self.assertRaises(QiskitOptimizationError): q_p.binary_var_dict(1, '', '') with self.assertRaises(QiskitOptimizationError): q_p.integer_var(0, 1, '') with self.assertRaises(QiskitOptimizationError): q_p = QuadraticProgram() q_p.binary_var_dict(keys=1, key_format='{}{}') with self.assertRaises(QiskitOptimizationError): q_p = QuadraticProgram() q_p.binary_var_dict(keys=0) with self.assertRaises(QiskitOptimizationError): q_p = QuadraticProgram() q_p.binary_var_dict(keys=1, key_format='_{{}}') with self.assertRaises(QiskitOptimizationError): q_p = QuadraticProgram() q_p.binary_var_dict(keys=2, key_format='') with self.assertRaises(QiskitOptimizationError): q_p = QuadraticProgram() q_p.binary_var_dict(keys=range(2), key_format='')