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 makeNPMatrix4(edges, cedges, n):
#QUBO
mdl = Model('MaxClique')
x = mdl.binary_var_list('x{}'.format(i) for i in range(n))
objective = mdl.sum([(x[i]) for i in range(n)])
mdl.maximize(objective)
mdl.prettyprint()
qp = QuadraticProgram()
qp.from_docplex(mdl)
#to matrix
H, offset = qp.to_ising()
H_matrix = np.real(H.to_matrix())
return H
def test_constructor(self):
""" test constructor """
quadratic_program = QuadraticProgram()
self.assertEqual(quadratic_program.name, '')
self.assertEqual(quadratic_program.status,
QuadraticProgram.Status.VALID)
self.assertEqual(quadratic_program.get_num_vars(), 0)
self.assertEqual(quadratic_program.get_num_linear_constraints(), 0)
self.assertEqual(quadratic_program.get_num_quadratic_constraints(), 0)
self.assertEqual(quadratic_program.objective.constant, 0)
self.assertDictEqual(quadratic_program.objective.linear.to_dict(), {})
self.assertDictEqual(quadratic_program.objective.quadratic.to_dict(),
{})
def solve(self):
# self.write_model()
# IBMQ.enable_account(os.getenv('IBM_TOKEN'))
backend = BasicAer.get_backend('ibmq_qasm_simulator')
# backend = Aer.get_backend('qasm_simulator')
prog = QuadraticProgram("molecConform")
prog.read_from_lp_file(str(self.LP_FILEPATH))
optimizer = GroverOptimizer(3, quantum_instance=backend)
results = optimizer.solve(prog)
print(results)
import pdb
pdb.set_trace()
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 makeNPMatrix1(edges, cedges, n):
#QUBO
mdl = Model('MaxClique')
x = mdl.binary_var_list('x{}'.format(i) for i in range(n))
q = (n - 1) * n / 2
objective = mdl.sum([(x[i] * x[j]) for (i, j) in edges] +
[-q * (x[i] * x[j]) for (i, j) in cedges])
mdl.maximize(objective)
qp = QuadraticProgram()
qp.from_docplex(mdl)
#to matrix
H, offset = qp.to_ising()
H_matrix = np.real(H.to_matrix())
return H
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_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_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_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_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_evaluate(self):
""" test evaluate. """
quadratic_program = QuadraticProgram()
x = [quadratic_program.continuous_var() for _ in range(5)]
coefficients_list = list(range(5))
linear = LinearExpression(quadratic_program, coefficients_list)
values_list = list(range(len(x)))
values_array = np.array(values_list)
values_dict_int = {i: i for i in range(len(x))}
values_dict_str = {'x{}'.format(i): i for i in range(len(x))}
for values in [
values_list, values_array, values_dict_int, values_dict_str
]:
self.assertEqual(linear.evaluate(values), 30)
def test_get_item(self):
""" test get_item. """
quadratic_program = QuadraticProgram()
for _ in range(5):
quadratic_program.continuous_var()
coefficients = [[0 for _ in range(5)] for _ in range(5)]
for i, v in enumerate(coefficients):
for j, _ in enumerate(v):
coefficients[min(i, j)][max(i, j)] += i * j
quadratic = QuadraticExpression(quadratic_program, coefficients)
for i, j_v in enumerate(coefficients):
for j, _ in enumerate(j_v):
if i == j:
self.assertEqual(quadratic[i, j], coefficients[i][j])
else:
self.assertEqual(quadratic[i, j], coefficients[i][j] + coefficients[j][i])
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_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.encode(op)
qubo_auto = lineq2penalty_auto.encode(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)
self.assertListEqual(result.x, result_auto.x)
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_evaluate(self):
""" test evaluate. """
quadratic_program = QuadraticProgram()
x = [quadratic_program.continuous_var() for _ in range(5)]
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
quadratic = QuadraticExpression(quadratic_program, coefficients_list)
values_list = list(range(len(x)))
values_array = np.array(values_list)
values_dict_int = {i: i for i in range(len(x))}
values_dict_str = {'x{}'.format(i): i for i in range(len(x))}
for values in [values_list, values_array, values_dict_int, values_dict_str]:
self.assertEqual(quadratic.evaluate(values), 900)
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_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,
status=OptimizationResultStatus.SUCCESS)
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_empty_problem(self):
""" Test empty problem """
op = QuadraticProgram()
conv = InequalityToEquality()
op = conv.encode(op)
conv = IntegerToBinary()
op = conv.encode(op)
conv = LinearEqualityToPenalty()
op = conv.encode(op)
conv = QuadraticProgramToIsing()
_, shift = conv.encode(op)
self.assertEqual(shift, 0.0)
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_valid_variable_type_deprecated(self):
"""Validate the types of the variables for QuadraticProgramToIsing."""
# Integer variable
with self.assertRaises(QiskitOptimizationError):
op = QuadraticProgram()
op.integer_var(0, 10, "int_var")
conv = QuadraticProgramToIsing()
_ = conv.encode(op)
# Continuous variable
with self.assertRaises(QiskitOptimizationError):
op = QuadraticProgram()
op.continuous_var(0, 10, "continuous_var")
conv = QuadraticProgramToIsing()
_ = conv.encode(op)
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_feasibility(self):
"""Tests feasibility methods."""
mod = Model('test')
# 0, 5
x = mod.continuous_var(
-1,
1,
'x',
)
y = mod.continuous_var(-10, 10, 'y')
mod.minimize(x + y)
mod.add(x + y <= 10, 'c0')
mod.add(x + y >= -10, 'c1')
mod.add(x + y == 5, 'c2')
mod.add(x * x + y <= 10, 'c3')
mod.add(x * x + y >= 5, 'c4')
mod.add(x * x + y * y == 25, 'c5')
q_p = QuadraticProgram()
q_p.from_docplex(mod)
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_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.convert(op)
self.assertEqual(len(op2.linear_constraints), 0)
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_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_penalize_integer(self):
""" Test PenalizeLinearEqualityConstraints with integer variables """
op = QuadraticProgram()
for i in range(3):
op.integer_var(name='x{}'.format(i), lowerbound=-3, upperbound=3)
# 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_evaluate_gradient(self):
""" test evaluate gradient. """
quadratic_program = QuadraticProgram()
x = [quadratic_program.continuous_var() for _ in range(5)]
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
quadratic = QuadraticExpression(quadratic_program, coefficients_list)
values_list = list(range(len(x)))
values_array = np.array(values_list)
values_dict_int = {i: i for i in range(len(x))}
values_dict_str = {'x{}'.format(i): i for i in range(len(x))}
grad_values = [0., 60., 120., 180., 240.]
for values in [
values_list, values_array, values_dict_int, values_dict_str
]:
np.testing.assert_almost_equal(quadratic.evaluate_gradient(values),
grad_values)
def test_continuous_variable_decode(self):
""" Test decode func of IntegerToBinaryConverter for continuous variables"""
try:
mdl = Model('test_continuous_varable_decode')
c = mdl.continuous_var(lb=0, ub=10.9, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
converter = IntegerToBinary()
op = converter.convert(op)
admm_params = ADMMParameters()
qubo_optimizer = MinimumEigenOptimizer(NumPyMinimumEigensolver())
continuous_optimizer = CplexOptimizer()
solver = ADMMOptimizer(
qubo_optimizer=qubo_optimizer,
continuous_optimizer=continuous_optimizer,
params=admm_params,
)
result = solver.solve(op)
new_x = converter.interpret(result.x)
self.assertEqual(new_x[0], 10.9)
except MissingOptionalLibraryError as ex:
self.skipTest(str(ex))
