def test_validation(self):
""" Validation Test """
num_var = 3
# validate an object type of the input.
with self.assertRaises(QiskitOptimizationError):
docplex._validate_input_model("Model")
# validate the types of the variables are binary or not
with self.assertRaises(QiskitOptimizationError):
mdl = Model(name='Error_integer_variables')
x = {
i: mdl.integer_var(name='x_{0}'.format(i))
for i in range(num_var)
}
obj_func = mdl.sum(x[i] for i in range(num_var))
mdl.maximize(obj_func)
docplex.get_operator(mdl)
# validate types of constraints are equality constraints or not.
with self.assertRaises(QiskitOptimizationError):
mdl = Model(name='Error_inequality_constraints')
x = {
i: mdl.binary_var(name='x_{0}'.format(i))
for i in range(num_var)
}
obj_func = mdl.sum(x[i] for i in range(num_var))
mdl.maximize(obj_func)
mdl.add_constraint(mdl.sum(x[i] for i in range(num_var)) <= 1)
docplex.get_operator(mdl)
def test_docplex_constant_and_quadratic_terms_in_object_function(self):
""" Docplex Constant and Quadratic terms in Object function test """
# Create an Ising Hamiltonian with docplex
laplacian = np.array([[-3., 1., 1., 1.],
[1., -2., 1., -0.],
[1., 1., -3., 1.],
[1., -0., 1., -2.]])
mdl = Model()
# pylint: disable=unsubscriptable-object
n = laplacian.shape[0]
bias = [0] * 4
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
couplers_func = mdl.sum(
2 * laplacian[i, j] * (2 * x[i] - 1) * (2 * x[j] - 1)
for i in range(n - 1) for j in range(i, n))
bias_func = mdl.sum(float(bias[i]) * x[i] for i in range(n))
ising_func = couplers_func + bias_func
mdl.minimize(ising_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
expected_result = -22
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset, expected_result)
def test_docplex_tsp(self):
""" Docplex tsp test """
# Generating a graph of 3 nodes
n = 3
ins = tsp.random_tsp(n)
graph = rx.PyGraph()
graph.add_nodes_from(np.arange(0, n, 1).tolist())
num_node = ins.dim
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='tsp')
x = {(i, p): mdl.binary_var(name='x_{0}_{1}'.format(i, p))
for i in range(num_node) for p in range(num_node)}
tsp_func = mdl.sum(
ins.w[i, j] * x[(i, p)] * x[(j, (p + 1) % num_node)]
for i in range(num_node) for j in range(num_node) for p
in range(num_node))
mdl.minimize(tsp_func)
for i in range(num_node):
mdl.add_constraint(mdl.sum(x[(i, p)] for p in range(num_node)) == 1)
for j in range(num_node):
mdl.add_constraint(mdl.sum(x[(i, j)] for i in range(num_node)) == 1)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
ee_expected = NumPyMinimumEigensolver()
expected_result = ee_expected.compute_minimum_eigenvalue(operator=QUBIT_OP_TSP)
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result.eigenvalue.real + OFFSET_TSP)
def test_docplex_maxcut(self):
""" Docplex maxcut test """
# Generating a graph of 4 nodes
n = 4
graph = rx.PyGraph()
graph.add_nodes_from(np.arange(0, n, 1).tolist())
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]
graph.add_edges_from(elist)
# Computing the weight matrix from the random graph
w = rx.graph_adjacency_matrix(graph, lambda weight: weight)
# Create an Ising Hamiltonian with docplex.
mdl = Model(name='max_cut')
mdl.node_vars = mdl.binary_var_list(list(range(4)), name='node')
maxcut_func = mdl.sum(w[i, j] * mdl.node_vars[i] * (1 - mdl.node_vars[j])
for i in range(n) for j in range(n))
mdl.maximize(maxcut_func)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
ee_expected = NumPyMinimumEigensolver()
expected_result = ee_expected.compute_minimum_eigenvalue(operator=QUBIT_OP_MAXCUT)
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result.eigenvalue.real + OFFSET_MAXCUT)
def test_constants_in_left_side_and_variables_in_right_side(self):
""" Test Constant values on the left-hand side of constraints and
variables on the right-hand side of constraints for the DOcplex translator"""
mdl = Model('left_constants_and_right_variables')
x = mdl.binary_var(name='x')
y = mdl.binary_var(name='y')
mdl.maximize(mdl.sum(x + y))
mdl.add_constraint(x == y)
qubit_op, offset = docplex.get_operator(mdl)
self.log.debug(qubit_op)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
self.assertEqual(result.eigenvalue.real + offset, -2)
actual_sol = result.eigenstate.to_matrix().tolist()
self.assertListEqual(actual_sol, [0, 0, 0, 1])
def test_docplex_integer_constraints(self):
""" Docplex Integer Constraints test """
# Create an Ising Hamiltonian with docplex
mdl = Model(name='integer_constraints')
x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(1, 5)}
max_vars_func = mdl.sum(x[i] for i in range(1, 5))
mdl.maximize(max_vars_func)
mdl.add_constraint(mdl.sum(i * x[i] for i in range(1, 5)) == 3)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver()
result = e_e.compute_minimum_eigenvalue(operator=qubit_op)
expected_result = -2
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset, expected_result)
