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
