def test_validation(self):
num_var = 3
# validate an object type of the input.
with self.assertRaises(AquaError):
docplex._validate_input_model("Model")
# validate the types of the variables are binary or not
with self.assertRaises(AquaError):
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_qubitops(mdl)
# validate types of constraints are equality constraints or not.
with self.assertRaises(AquaError):
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_qubitops(mdl)
def test_docplex_tsp(self):
# Generating a graph of 3 nodes
n = 3
ins = tsp.random_tsp(n)
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
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 p in range(num_node):
mdl.add_constraint(
mdl.sum(x[(i, p)] for i in range(num_node)) == 1)
qubitOp, offset = docplex.get_qubitops(mdl)
ee = ExactEigensolver(qubitOp, k=1)
result = ee.run()
ee_expected = ExactEigensolver(qubitOp_tsp, k=1)
expected_result = ee_expected.run()
# Compare objective
self.assertEqual(result['energy'] + offset,
expected_result['energy'] + offset_tsp)
def test_docplex_maxcut(self):
# Generating a graph of 4 nodes
n = 4
G = nx.Graph()
G.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)]
G.add_weighted_edges_from(elist)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp['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)
qubitOp, offset = docplex.get_qubitops(mdl)
ee = ExactEigensolver(qubitOp, k=1)
result = ee.run()
ee_expected = ExactEigensolver(qubitOp_maxcut, k=1)
expected_result = ee_expected.run()
# Compare objective
self.assertEqual(result['energy'] + offset,
expected_result['energy'] + offset_maxcut)
def get_cost_hamiltonian(rates, m1=1., m2=1.): # ordered dict
mdl = Model(name="arbitrage")
x = {(a, b): mdl.binary_var(name=a + b) for (a, b) in rates.keys()}
fun = mdl.sum(np.log(r) * x[k] for k, r in rates.items())
assets = set(x for x, y in rates.keys())
for a in assets:
for x1, y1 in rates.keys():
if x1 != a: continue
for x2, y2 in rates.keys():
if x2 != a: continue
fun -= m1 * x[(x1, y1)] * x[(x2, y2)]
for x2, y2 in rates.keys():
if y2 != a: continue
fun += 2. * m1 * x[(x1, y1)] * x[(x2, y2)]
for x1, y1 in rates.keys():
if y1 != a: continue
for x2, y2 in rates.keys():
if y2 != a: continue
fun -= m1 * x[(x1, y1)] * x[(x2, y2)]
for a in assets:
for x1, y1 in rates.keys():
if x1 != a: continue
fun += m2 * x[(x1, y1)]
for x2, y2 in rates.keys():
if x2 != a: continue
fun -= m2 * x[(x1, y1)] * x[(x2, y2)]
mdl.maximize(fun)
operator, _ = docplex.get_qubitops(mdl)
return operator
def test_docplex_constant_and_quadratic_terms_in_object_function(self):
""" Docplex Constant and Quadratic terms in Object function test """
# Create an Ising Homiltonian with docplex
laplacian = np.array([[-3., 1., 1., 1.], [1., -2., 1., -0.],
[1., 1., -3., 1.], [1., -0., 1., -2.]])
mdl = Model()
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_qubitops(mdl)
e_e = ExactEigensolver(qubit_op, k=1)
result = e_e.run()
expected_result = -22
# Compare objective
self.assertEqual(result['energy'] + offset, expected_result)
def test_docplex_integer_constraints(self):
# Create an Ising Homiltonian 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)
qubitOp, offset = docplex.get_qubitops(mdl)
ee = ExactEigensolver(qubitOp, k=1)
result = ee.run()
expected_result = -2
# Compare objective
self.assertEqual(result['energy'] + offset, expected_result)
def optimize_f(precision, coefs_param, beta):
coefs = coefs_param.copy()
coefs.append(0)
coefs_restr = (1, 1, 1)
lista_vars = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
mdl = Model()
variables = []
for num_var in range(len(coefs)):
tmp = {
i: mdl.binary_var(name=(lista_vars[num_var] + '_{0}').format(i))
for i in range(precision)
}
variables.append(tmp)
# x = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(precision)}
# y = {i: mdl.binary_var(name='y_{0}'.format(i)) for i in range(precision)}
# z = {i: mdl.binary_var(name='z_{0}'.format(i)) for i in range(precision)}
#print(variables)
# Object function
# my_func = mdl.sum(coefs[0]*(2**i)*x[i]+coefs[1]*(2**i)*y[i]+(2**i)*coefs[2]*z[i] for i in range(precision))
# my_func = mdl.sum(coefs[j]*(2**i)*vars[j][i] for j in range(len(coefs)) for i in range(precision))
my_func = mdl.sum(coefs[j] * (2**i) * variables[j][i]
for j in range(len(coefs)) for i in range(precision))
# (x[i] for i in range(precision)), (y[i] for i in range(precision)), (z[i] for i in range(precision)
# tmp = {0:{'var':x,'coef':coefs_restr[0]},
# 1:{'var':y,'coef':coefs_restr[1]},
# 2:{'var':z,'coef':coefs_restr[2]}}
mdl.maximize(my_func)
inverted_beta = dameInversoBinario(beta, precision, len(coefs))
# mdl.add_constraint(mdl.sum( tmp[v]['var'][i]*(2**i)*tmp[v]['coef'] for v in range(len(coefs)) for i in range(precision)) == beta)
# mdl.add_constraint(mdl.sum( x[0] + x[1]*(2) + x[2]*(4) + y[0] + y[1]*(2) + y[2]*(4) + z[0] + z[1]*(2) + z[2]*(4) ) == inverted_beta)
# mdl.add_constraint(mdl.sum( variables[0][0] + variables[0][1]*(2) + variables[0][2]*(4) + variables[1][0] + variables[1][1]
# *(2) + variables[1][2]*(4) + variables[2][0] + variables[2][1]*(2) + variables[2][2]*(4) ) == inverted_beta)
mdl.add_constraint(
mdl.sum(variables[v][i] * 2**i for v in range(len(coefs))
for i in range(precision)) == inverted_beta)
# mdl.add_constraint(mdl.sum( -x[0] - x[1]*(2) - x[2]*(4) - y[0] - y[1]*(2) - y[2]*(4) - z[0] - z[1]*(2) - z[2]*(4) ) == 6)
# mdl.add_constraint(mdl.sum( -1*tmp[v]['var'][i]*(2**i)*tmp[v]['coef'] for v in range(len(coefs)) for i in range(precision)) == -beta)
qubitOp_docplex, offset_docplex = docplex.get_qubitops(mdl)
#print(qubitOp_docplex)
# algo_input = EnergyInput(qubitOp_docplex)
# print(algo_input.)
# ee = VQE(qubitOp_docplex)
# ee.run()
ee = ExactEigensolver(qubitOp_docplex, k=1)
result_ee = ee.run()
x_ee = max_cut.sample_most_likely(result_ee['eigvecs'][0])
print('solution:', max_cut.get_graph_solution(x_ee))
solucion_ee = max_cut.get_graph_solution(x_ee)
return (solucion_ee, None)
"""
algorithm_cfg = {
'name': 'ExactEigensolver',
}
params = {
'problem': {'name': 'ising'},
'algorithm': algorithm_cfg
}
result = run_algorithm(params,algo_input)
"""
# x = max_cut.sample_most_likely(result['eigvecs'][0])
# print('energy:', result['energy'])
# print('max-cut objective:', result['energy'] + offset_docplex)
# print('solution:', max_cut.get_graph_solution(x))
# print('solution objective:', max_cut.max_cut_value(x, w))
seed = 10598
# change optimizer(spsa), change ry (riyc)
spsa = SPSA(max_trials=300)
ry = RY(qubitOp_docplex.num_qubits, depth=6, entanglement='linear')
vqe = VQE(qubitOp_docplex, ry, spsa, 'matrix')
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend,
seed=seed,
seed_transpiler=seed)
result = vqe.run(quantum_instance)
x = max_cut.sample_most_likely(result['eigvecs'][0])
print('solution:', max_cut.get_graph_solution(x))
return (solucion_ee, max_cut.get_graph_solution(x))
