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))