def test_docplex_tsp(self):
""" Docplex tsp test """
# Generating a graph of 3 nodes
n = 3
ins = tsp.random_tsp(n)
graph = nx.Graph()
graph.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 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(qubit_op)
result = e_e.run()
ee_expected = NumPyMinimumEigensolver(QUBIT_OP_TSP)
expected_result = ee_expected.run()
# 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 = 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)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = graph.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)
qubit_op, offset = docplex.get_operator(mdl)
e_e = NumPyMinimumEigensolver(qubit_op)
result = e_e.run()
ee_expected = NumPyMinimumEigensolver(QUBIT_OP_MAXCUT)
expected_result = ee_expected.run()
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result.eigenvalue.real + OFFSET_MAXCUT)
def test_tsp(self):
""" TSP test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
order = tsp.get_tsp_solution(x)
np.testing.assert_array_equal(order, [1, 2, 0])
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(qubit_op)
result = e_e.run()
expected_result = -22
# Compare objective
self.assertAlmostEqual(result.eigenvalue.real + offset,
expected_result)
def test_deprecated_qft(self):
"""Test the QPE algorithm on the deprecated QFT component."""
qubit_op = self._dict['QUBIT_OP_SIMPLE']
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
warnings.filterwarnings('ignore', category=DeprecationWarning)
iqft = Standard(5)
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices=1,
num_ancillae=5,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=1,
seed_simulator=1)
# run qpe
result = qpe.run(quantum_instance)
warnings.filterwarnings('always', category=DeprecationWarning)
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=2e-2)
def test_partition(self):
""" Partition test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
if x[0] != 0:
x = np.logical_not(x) * 1
np.testing.assert_array_equal(x, [0, 1, 0])
def test_set_packing(self):
""" set packing test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = set_packing.get_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 1])
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_vertex_cover(self):
""" Vertex Cover test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
np.testing.assert_array_equal(sol, [0, 0, 1])
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_portfolio(self):
""" portfolio test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
selection = sample_most_likely(result.eigenstate)
value = portfolio.portfolio_value(selection, self.muu, self.sigma,
self.risk, self.budget, self.penalty)
np.testing.assert_array_equal(selection, [0, 1, 1, 0])
self.assertAlmostEqual(value, -0.00679917)
def test_tsp(self):
""" TSP test """
algo = NumPyMinimumEigensolver(self.qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
# print(self.qubit_op.to_opflow().eval(result.eigenstate).adjoint().eval(result.eigenstate))
order = tsp.get_tsp_solution(x)
np.testing.assert_equal(tsp.tsp_value(order, self.ins.w),
tsp.tsp_value([1, 2, 0], self.ins.w))
def test_stable_set(self):
""" Stable set test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue.real, -29.5)
self.assertAlmostEqual(result.eigenvalue.real + self.offset, -25.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 0, 1, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (3.0, False))
def test_mapping(self):
""" mapping test """
qubit_op = self.bos_op.mapping('direct', threshold=1e-5)
algo = NumPyMinimumEigensolver(
qubit_op,
filter_criterion=self.bos_op.direct_mapping_filtering_criterion)
result = algo.run()
gs_energy = np.real(result['eigenvalue'])
self.assertAlmostEqual(gs_energy, self.reference_energy, places=4)
def test_clique(self):
""" Clique test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = clique.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1])
oracle = self._brute_force()
self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k),
oracle)
def test_graph_partition(self):
""" Graph Partition test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
# check against the oracle
ising_sol = graph_partition.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 0, 1])
oracle = self._brute_force()
self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_iqpe(self, distance):
""" iqpe test """
self.log.debug('Testing End-to-End with IQPE on H2 with '
'inter-atomic distance %s.', distance)
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 {}'.format(distance),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
molecule = driver.run()
qubit_mapping = 'parity'
fer_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
qubit_op = fer_op.mapping(map_type=qubit_mapping, threshold=1e-10)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, 2)
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
reference_energy = results.eigenvalue.real
self.log.debug('The exact ground state energy is: %s', results.eigenvalue.real)
num_particles = molecule.num_alpha + molecule.num_beta
two_qubit_reduction = True
num_orbitals = qubit_op.num_qubits + (2 if two_qubit_reduction else 0)
num_time_slices = 1
num_iterations = 6
state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction)
iqpe = IQPE(qubit_op, state_in, num_time_slices, num_iterations,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = qiskit.BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=100)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s', result.top_measurement_label)
self.log.debug('top result in decimal: %s', result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final energy from QPE: %s', result.eigenvalue.real)
self.log.debug('reference energy: %s', reference_energy)
self.log.debug('ref energy (transformed): %s',
(reference_energy + result.translation) * result.stretch)
self.log.debug('ref binary str label: %s', decimal_to_binary(
(reference_energy + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result.eigenvalue.real, reference_energy, significant=2)
def test_cme(self):
""" Basic test """
algo = NumPyMinimumEigensolver(self.qubit_op,
aux_operators=self.aux_ops)
result = algo.run()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
def test_iqpe(self, qubit_op, simulator, num_time_slices, num_iterations,
use_circuits):
""" iqpe test """
self.log.debug('Testing IQPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
if use_circuits:
state_in = QuantumCircuit(qubit_op.num_qubits)
state_in.initialize(ref_eigenvec.primitive.data, state_in.qubits)
else:
with warnings.catch_warnings():
warnings.filterwarnings('ignore', category=DeprecationWarning)
state_in = Custom(qubit_op.num_qubits,
state_vector=ref_eigenvec)
iqpe = IQPE(qubit_op,
state_in,
num_time_slices,
num_iterations,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from IQPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval.real + result.translation) *
result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval.real,
significant=2)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
"""Test the QPE algorithm."""
self.log.debug('Testing QPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = QFT(n_ancillae).inverse()
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=1,
seed_simulator=1)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=2e-2)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
""" QPE test """
self.log.debug('Testing QPE')
tmp_qubit_op = qubit_op.copy()
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPEMinimumEigensolver(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result.top_measurement_label)
self.log.debug('top result in decimal: %s',
result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug(
'reference binary str label: %s',
decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result.eigenvalue.real,
ref_eigenval.real,
significant=2)
self.assertEqual(tmp_qubit_op, qubit_op,
"Operator is modified after QPE.")
def _run_knapsack(values, weights, max_weight):
qubit_op, _ = knapsack.get_operator(values, weights, max_weight)
algo = NumPyMinimumEigensolver(qubit_op)
result = algo.run()
x = sample_most_likely(result.eigenstate)
solution = knapsack.get_solution(x, values)
value, weight = knapsack.knapsack_value_weight(solution, values,
weights)
return solution, value, weight
def test_exact_cover(self):
""" Exact Cover test """
algo = NumPyMinimumEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
x = sample_most_likely(result.eigenstate)
ising_sol = exact_cover.get_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 1, 0])
oracle = self._brute_force()
self.assertEqual(
exact_cover.check_solution_satisfiability(ising_sol,
self.list_of_subsets),
oracle)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae, use_circuit_library):
""" QPE test """
self.log.debug('Testing QPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
if use_circuit_library:
iqft = QFT(n_ancillae).inverse()
else:
# ignore deprecation warnings from QFTs
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s', result.top_measurement_label)
self.log.debug('top result in decimal: %s', result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug('reference binary str label: %s', decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result.eigenvalue.real, ref_eigenval.real, significant=2)
if not use_circuit_library:
warnings.filterwarnings(action="always", category=DeprecationWarning)
def test_cme_reuse(self):
""" Test reuse """
# Start with no operator or aux_operators, give via compute method
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(self.qubit_op, algo.operator)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set operator to None and go again
algo.operator = None
with self.assertRaises(AquaError):
_ = algo.run()
# Set operator back as it was and go again
algo.operator = self.qubit_op
result = algo.compute_minimum_eigenvalue()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Add aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=self.aux_ops)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
# "Remove" aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=[])
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set aux_operators and go again
algo.aux_operators = self.aux_ops
result = algo.compute_minimum_eigenvalue()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
np.testing.assert_array_equal(self.aux_ops, algo.aux_operators)
# Finally just set one of aux_operators and main operator, remove aux_operators
result = algo.compute_minimum_eigenvalue(self.aux_ops[0], [])
self.assertAlmostEqual(result.eigenvalue, 2 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
def test_cme_filter_empty(self):
""" Test with filter always returning False """
# define filter criterion
# pylint: disable=unused-argument
def criterion(x, v, a_v):
return False
algo = NumPyMinimumEigensolver(self.qubit_op,
aux_operators=self.aux_ops,
filter_criterion=criterion)
result = algo.run()
self.assertEqual(result.eigenvalue, None)
self.assertEqual(result.eigenstate, None)
self.assertEqual(result.aux_operator_eigenvalues, None)
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(qubit_op)
result = e_e.run()
expected_result = -2
# Compare objective
self.assertEqual(result.eigenvalue.real + offset, expected_result)
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)
print(qubit_op.print_details())
e_e = NumPyMinimumEigensolver(qubit_op)
result = e_e.run()
self.assertEqual(result['eigenvalue'] + offset, -2)
actual_sol = result['eigenstate'].to_matrix().tolist()
self.assertListEqual(actual_sol, [0, 0, 0, 1])
def test_cme_filter(self):
""" Basic test """
# define filter criterion
# pylint: disable=unused-argument
def criterion(x, v, a_v):
return v >= -0.5
algo = NumPyMinimumEigensolver(self.qubit_op,
aux_operators=self.aux_ops,
filter_criterion=criterion)
result = algo.run()
self.assertAlmostEqual(result.eigenvalue, -0.22491125 + 0j)
self.assertEqual(len(result.aux_operator_eigenvalues), 2)
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[0], [2, 0])
np.testing.assert_array_almost_equal(
result.aux_operator_eigenvalues[1], [0, 0])
def test_cme_fail(self):
""" Test no operator """
algo = NumPyMinimumEigensolver()
with self.assertRaises(AquaError):
_ = algo.run()
nx.draw_networkx_edge_labels(G2,
pos,
font_color='b',
edge_labels=edge_labels)
qubitOp, offset = tsp.get_operator(ins)
print('Offset:', offset)
print('Ising Hamiltonian:')
print(qubitOp.print_details())
qp = QuadraticProgram()
qp.from_ising(qubitOp, offset, linear=True)
qp.to_docplex().prettyprint()
result = exact.solve(qp)
print(result)
ee = NumPyMinimumEigensolver(qubitOp)
result = ee.run()
# print('energy:', result.eigenvalue.real)
# print('tsp objective:', result.eigenvalue.real + offset)
x = sample_most_likely(result.eigenstate)
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
# draw_tsp_solution(G, z, colors, pos)
# draw_tsp_solution(G, best_order, colors, pos)
