def test_admm_ex4_no_bin_var_in_objective(self):
"""Modified Example 4 as a unit test. See the description of the previous test.
This test differs from the previous in the objective: one binary variable
is omitted in objective to test a problem when a binary variable defined but is used only
in constraints.
"""
mdl = Model('ex4')
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
# pylint:disable=invalid-name
t = mdl.binary_var(name='t')
b = 2
mdl.minimize(v + t)
mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= b, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=False)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_ex4(self):
"""Example 4 as a unit test. Example 4 is reported in:
Gambella, C., & Simonetto, A. (2020).
Multi-block ADMM Heuristics for Mixed-Binary Optimization on Classical
and Quantum Computers.
arXiv preprint arXiv:2001.02069."""
mdl = Model('ex4')
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
# pylint:disable=invalid-name
t = mdl.binary_var(name='t')
b = 2
mdl.minimize(v + w + t)
mdl.add_constraint(2 * v + 10 * w + t <= 3, "cons1")
mdl.add_constraint(v + w + t >= b, "cons2")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=False)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 1.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(2., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_converter_list(self):
"""Test converters list"""
# Input.
model = Model()
x_0 = model.binary_var(name='x0')
x_1 = model.binary_var(name='x1')
model.maximize(-x_0 + 2 * x_1)
op = QuadraticProgram()
op.from_docplex(model)
# Get the optimum key and value.
n_iter = 8
# a single converter.
qp2qubo = QuadraticProgramToQubo()
gmf = GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=qp2qubo)
results = gmf.solve(op)
self.validate_results(op, results)
# a list of converters
ineq2eq = InequalityToEquality()
int2bin = IntegerToBinary()
penalize = LinearEqualityToPenalty()
converters = [ineq2eq, int2bin, penalize]
gmf = GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=converters)
results = gmf.solve(op)
self.validate_results(op, results)
# invalid converters
with self.assertRaises(TypeError):
invalid = [qp2qubo, "invalid converter"]
GroverOptimizer(4,
num_iterations=n_iter,
quantum_instance=self.q_instance,
converters=invalid)
def test_admm_maximization(self):
"""Tests a simple maximization problem using ADMM optimizer"""
mdl = Model('simple-max')
c = mdl.continuous_var(lb=0, ub=10, name='c')
x = mdl.binary_var(name='x')
mdl.maximize(c + x * x)
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters()
solver = ADMMOptimizer(params=admm_params,
continuous_optimizer=CobylaOptimizer())
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([10, 0], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(10, solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
def test_admm_ex6_max(self):
"""Example 6 as maximization"""
mdl = Model('ex6-max')
# pylint:disable=invalid-name
v = mdl.binary_var(name='v')
w = mdl.binary_var(name='w')
t = mdl.binary_var(name='t')
u = mdl.continuous_var(name='u')
# mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
mdl.maximize(-v - w - t - 5 * (u - 2)**2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
op = QuadraticProgram()
op.from_docplex(mdl)
admm_params = ADMMParameters(rho_initial=1001,
beta=1000,
factor_c=900,
maxiter=100,
three_block=True,
tol=1.e-6)
solver = ADMMOptimizer(params=admm_params)
solution = solver.solve(op)
self.assertIsNotNone(solution)
self.assertIsInstance(solution, ADMMOptimizationResult)
self.assertIsNotNone(solution.x)
np.testing.assert_almost_equal([1., 0., 0., 2.], solution.x, 3)
self.assertIsNotNone(solution.fval)
np.testing.assert_almost_equal(-1., solution.fval, 3)
self.assertIsNotNone(solution.state)
self.assertIsInstance(solution.state, ADMMState)
# qc.cx(c[0], c[1])
#Acting the gates on circuit
for i in range (g):
gates()
# Prepare the Ising Hamiltonian
#n = 3 #number of qubits
a = 1.0
k = 2
t = range(1, n+1)
mdl = Model()# build model with docplex
x = [mdl.binary_var() for i in range(n)]
objective = a*(k - mdl.sum(t[i]*x[i] for i in range(n)))**2
mdl.minimize(objective)
qp = QuadraticProgram()# convert to Qiskit's quadratic program
qp.from_docplex(mdl)
qp2ising = QuadraticProgramToIsing()# convert to Ising Hamiltonian
H, offset = qp2ising.encode(qp)
H_matrix = np.real(H.to_matrix())
psi = StateFn(qc)
expectation_value = (~psi @ H @ psi).eval()
print(psi)
print(expectation_value)
from qiskit.aqua.algorithms import NumPyMinimumEigensolver
from qiskit.optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer
from qiskit.optimization.problems import QuadraticProgram
from qiskit import BasicAer
from docplex.mp.model import Model
backend = BasicAer.get_backend("statevector_simulator")
model = Model()
x0 = model.binary_var(name="x0")
x1 = model.binary_var(name="x1")
x2 = model.binary_var(name="x2")
model.minimize(-x0 + 2 * x1 - 3 * x2 - 2 * x0 * x2 - 1 * x1 * x2)
qp = QuadraticProgram()
qp.from_docplex(model)
print(qp.export_as_lp_string())
from qiskit.aqua import QuantumInstance
grover_optimizer = GroverOptimizer(6, num_iterations=10, quantum_instance=backend)
results = grover_optimizer.solve(qp)
print("x={}".format(results.x))
print("fval={}".format(results.fval))
exact_solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
exact_result = exact_solver.solve(qp)
print("x={}".format(exact_result.x))
print("fval={}".format(exact_result.fval))
# Since the `pytket` extension modules provide an interface to the widest variety of devices and simulators out of all major quantum software platforms, the simplest advantage to obtain through `pytket` is to try using some alternative backends.
