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 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_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_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_linear_inequality_to_penalty7(self): """Test special constraint to penalty 6 x-y >= 0 -> P(y-x*y)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() 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, 0, "P(y-xy)") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) penalty = 1 linear = {"y": penalty} quadratic = {("x", "y"): -1 * penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test maximize with self.subTest("Maximize"): linear = {"x": 2, "y": 1} op.maximize(linear=linear) penalty = 4 linear["y"] = linear["y"] - penalty quadratic = {("x", "y"): penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test minimize with self.subTest("Minimize"): linear = {"x": 2, "y": 1} op.minimize(linear={"x": 2, "y": 1}) penalty = 4 linear["y"] = linear["y"] + penalty quadratic = {("x", "y"): -1 * penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0)
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 _sample_code(self): def print(*args): """ overloads print to log values """ if args: self.log.debug(args[0], *args[1:]) # --- 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.algorithms import QAOA from qiskit.algorithms.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 # ---------------------------------------------------------------------- return result
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_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_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_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_linear_inequality_to_penalty8(self): """Test combinations of inequality constraints""" with self.subTest("minimize 1"): op = QuadraticProgram() op.binary_var("x") op.binary_var("y") op.binary_var("z") op.integer_var(-1, 4, "q") op.minimize(linear={ "x": 1, "y": 1, "z": 1 }, quadratic={("q", "q"): -1}) op.linear_constraint({"x": 1, "y": -1}, "<=", 0) op.linear_constraint({"x": 1, "y": 1, "z": 1}, "<=", 1) op2 = LinearInequalityToPenalty().convert(op) self.assertEqual(op2.get_num_vars(), 4) self.assertEqual(op2.get_num_binary_vars(), 3) self.assertEqual(op2.get_num_integer_vars(), 1) self.assertEqual(op2.get_num_continuous_vars(), 0) self.assertEqual(op2.get_num_linear_constraints(), 0) self.assertEqual(op2.get_num_quadratic_constraints(), 0) obj = op2.objective self.assertEqual(obj.constant, 0) self.assertDictEqual(obj.linear.to_dict(use_name=True), { "x": 21, "y": 1, "z": 1 }) self.assertDictEqual( obj.quadratic.to_dict(use_name=True), { ("x", "z"): 20, ("y", "z"): 20, ("q", "q"): -1 }, ) with self.subTest("maximize 1"): op = QuadraticProgram() op.binary_var("x") op.binary_var("y") op.binary_var("z") op.integer_var(-1, 4, "q") op.maximize(linear={ "x": 1, "y": 1, "z": 1 }, quadratic={("q", "q"): -1}) op.linear_constraint({"x": 1, "y": -1}, "<=", 0) op.linear_constraint({"x": 1, "y": 1, "z": 1}, "<=", 1) op2 = LinearInequalityToPenalty().convert(op) self.assertEqual(op2.get_num_vars(), 4) self.assertEqual(op2.get_num_binary_vars(), 3) self.assertEqual(op2.get_num_integer_vars(), 1) self.assertEqual(op2.get_num_continuous_vars(), 0) self.assertEqual(op2.get_num_linear_constraints(), 0) self.assertEqual(op2.get_num_quadratic_constraints(), 0) obj = op2.objective self.assertEqual(obj.constant, 0) self.assertDictEqual(obj.linear.to_dict(use_name=True), { "x": -19, "y": 1, "z": 1 }) self.assertDictEqual( obj.quadratic.to_dict(use_name=True), { ("x", "z"): -20, ("y", "z"): -20, ("q", "q"): -1 }, ) with self.subTest("minimize 2"): op = QuadraticProgram() op.binary_var("x") op.binary_var("y") op.binary_var("z") op.integer_var(-1, 4, "q") op.minimize(linear={ "x": 1, "y": 1, "z": 1 }, quadratic={("q", "q"): -1}) op.linear_constraint({"x": 1, "y": -1}, ">=", 0) op.linear_constraint({"x": 1, "y": 1, "z": 1}, ">=", 2) op2 = LinearInequalityToPenalty().convert(op) self.assertEqual(op2.get_num_vars(), 4) self.assertEqual(op2.get_num_binary_vars(), 3) self.assertEqual(op2.get_num_integer_vars(), 1) self.assertEqual(op2.get_num_continuous_vars(), 0) self.assertEqual(op2.get_num_linear_constraints(), 0) self.assertEqual(op2.get_num_quadratic_constraints(), 0) obj = op2.objective self.assertEqual(obj.constant, 60) self.assertDictEqual(obj.linear.to_dict(use_name=True), { "x": -39, "y": -19, "z": -39 }) self.assertDictEqual( obj.quadratic.to_dict(use_name=True), { ("x", "z"): 20, ("y", "z"): 20, ("q", "q"): -1 }, ) with self.subTest("maximize 2"): op = QuadraticProgram() op.binary_var("x") op.binary_var("y") op.binary_var("z") op.integer_var(-1, 4, "q") op.maximize(linear={ "x": 1, "y": 1, "z": 1 }, quadratic={("q", "q"): -1}) op.linear_constraint({"x": 1, "y": -1}, ">=", 0) op.linear_constraint({"x": 1, "y": 1, "z": 1}, ">=", 2) op2 = LinearInequalityToPenalty().convert(op) self.assertEqual(op2.get_num_vars(), 4) self.assertEqual(op2.get_num_binary_vars(), 3) self.assertEqual(op2.get_num_integer_vars(), 1) self.assertEqual(op2.get_num_continuous_vars(), 0) self.assertEqual(op2.get_num_linear_constraints(), 0) self.assertEqual(op2.get_num_quadratic_constraints(), 0) obj = op2.objective self.assertEqual(obj.constant, -60) self.assertDictEqual(obj.linear.to_dict(use_name=True), { "x": 41, "y": 21, "z": 41 }) self.assertDictEqual( obj.quadratic.to_dict(use_name=True), { ("x", "z"): -20, ("y", "z"): -20, ("q", "q"): -1 }, )
def test_linear_inequality_to_penalty1(self): """Test special constraint to penalty x+y <= 1 -> P(x*y)""" op = QuadraticProgram() lip = LinearInequalityToPenalty() 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.LE, 1, "P(xy)") # Test with no max/min with self.subTest("No max/min"): self.assertEqual(op.get_num_linear_constraints(), 1) lip.penalty = 1 quadratic = {("x", "y"): lip.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 with self.subTest("Maximize"): linear = {"x": 2, "y": 1} op.maximize(linear=linear) lip.penalty = 5 quadratic = {("x", "y"): -1 * lip.penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test minimize with self.subTest("Minimize"): linear = {"x": 2, "y": 1} op.minimize(linear=linear) lip.penalty = 5 quadratic = {("x", "y"): lip.penalty} op2 = lip.convert(op) ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 0) # Test combination with self.subTest("Combination"): op = QuadraticProgram() lip = LinearInequalityToPenalty() op.binary_var(name="x") op.binary_var(name="y") op.binary_var(name="z") op.binary_var(name="w") linear = {"x": 2, "y": 1, "z": -1, "w": 1} quadratic = {("y", "z"): -2, ("w", "w"): 1} op.minimize(linear=linear, quadratic=quadratic) linear_constraint = {"x": 1, "w": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(xw)") linear_constraint = {"y": 1, "z": 1} op.linear_constraint(linear_constraint, Constraint.Sense.LE, 1, "P(yz)") linear_constraint = {"y": 2, "z": 1} op.linear_constraint(linear_constraint, Constraint.Sense.EQ, 1, "None 1") quadratic_constraint = {("x", "x"): -2, ("y", "w"): 1} op.quadratic_constraint(linear_constraint, quadratic_constraint, Constraint.Sense.LE, 1, "None 2") lip.penalty = 5 op2 = lip.convert(op) quadratic[("x", "w")] = lip.penalty quadratic[("y", "z")] = quadratic[("y", "z")] + lip.penalty ldct = op2.objective.linear.to_dict(use_name=True) qdct = op2.objective.quadratic.to_dict(use_name=True) self.assertEqual(ldct, linear) self.assertEqual(qdct, quadratic) self.assertEqual(op2.get_num_linear_constraints(), 1) self.assertEqual(op2.get_num_quadratic_constraints(), 1)
def quadratibot(nb_stick: int, past: list, backend_sim: Aer) -> list: """Quadratic + QAOA function Args: nb_stick: nb of stick left past: past turn backend_sim: backend for quantum Return: Gates to use """ def get_quantum_solution_for(quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None): _eval_count = 0 def callback(eval_count, parameters, mean, std): nonlocal _eval_count _eval_count = eval_count # Create solver and optimizer solver = QAOA( optimizer=optimizer, quantum_instance=quantumInstance, callback=callback, max_evals_grouped=3, ) # Create optimizer for solver optimizer = MinimumEigenOptimizer(solver) # Get result from optimizer result = optimizer.solve(quadprog) return result, _eval_count # Check number of stick max if nb_stick >= 3: max_stick = 3 else: max_stick = nb_stick # Check the past poten_stick = nb_stick for i in range(len(past)): if past[i] == "/": poten_stick += 0.5 if past[i] == "¬": u = 1 if len(past) - 1 >= i + u: while past[i + u] == "¬": u += 1 if past[i + u] == "/": poten_stick += 0.5 # Check last turn last_st = 0 if past[0] == "¬": u = 1 while past[0 + u] == "¬": u += 1 if past[0 + u] == "/": last_st = 0.5 if past[0] == "/": last_st = 0.5 quadprog = QuadraticProgram(name="qnim") quadprog.integer_var(name="x", lowerbound=0, upperbound=max_stick) quadprog.integer_var(name="sup", lowerbound=0, upperbound=max_stick) quadprog.integer_var(name="intric", lowerbound=0, upperbound=max_stick) quadprog.maximize( linear={ "x": 1, "sup": 0.5, "intric": last_st }, quadratic={("sup", "intric"): 0.5}, ) # General constraints quadprog.linear_constraint(linear={ "x": 1, "sup": 1, "intric": 1 }, sense=">", rhs=0, name="gen_min") quadprog.linear_constraint( linear={ "x": 1, "sup": 1, "intric": 1 }, sense="<=", rhs=max_stick, name="gen_max", ) # Mod4 constraints if math.ceil(poten_stick % 4) - 0.5 > 0: quadprog.linear_constraint( linear={ "x": 1, "sup": 1 }, sense="<=", rhs=math.ceil(poten_stick % 4), name="qua_mod4", ) if nb_stick % 4 - 1 > 0: quadprog.linear_constraint( linear={ "x": 1, "sup": 1, "intric": 1 }, sense="<=", rhs=nb_stick % 4 - 1, name="cla_mod4", ) # Get QAOA result final_result = [] simulator_instance = QuantumInstance(backend=backend_sim) qaoa_result, qaoa_eval_count = get_quantum_solution_for( quadprog, simulator_instance) # Format and print result for cropHectares, cropName in zip(qaoa_result.x, qaoa_result.variable_names): for i in range(int(cropHectares)): final_result.append(cropName) return final_result