def test_qaoa_qc_mixer_many_parameters(self):
""" QAOA test with a mixer as a parameterized circuit with the num of parameters > 1. """
seed = 0
aqua_globals.random_seed = seed
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
for i in range(num_qubits):
theta = Parameter('θ' + str(i))
mixer.rx(theta, range(num_qubits))
backend = BasicAer.get_backend('statevector_simulator')
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer=optimizer,
p=2,
mixer=mixer,
quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
self.log.debug(x)
graph_solution = max_cut.get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]), S1)
def test_qaoa(self, w, prob, m, solutions, convert_to_matrix_op):
""" QAOA test """
seed = 0
aqua_globals.random_seed = seed
self.log.debug('Testing %s-step QAOA with MaxCut on graph\n%s', prob,
w)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, offset = max_cut.get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer, prob, mixer=m, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
self.log.debug('energy: %s', result.eigenvalue.real)
self.log.debug('time: %s', result.optimizer_time)
self.log.debug('maxcut objective: %s',
result.eigenvalue.real + offset)
self.log.debug('solution: %s', graph_solution)
self.log.debug('solution objective: %s', max_cut.max_cut_value(x, w))
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_qaoa_qc_mixer(self, w, prob, solutions, convert_to_matrix_op):
""" QAOA test with a mixer as a parameterized circuit"""
seed = 0
aqua_globals.random_seed = seed
self.log.debug(
'Testing %s-step QAOA with MaxCut on graph with '
'a mixer as a parameterized circuit\n%s', prob, w)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
if convert_to_matrix_op:
qubit_op = qubit_op.to_matrix_op()
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
theta = Parameter('θ')
mixer.rx(theta, range(num_qubits))
q_i = QuantumInstance(backend,
seed_simulator=seed,
seed_transpiler=seed)
qaoa = QAOA(optimizer, prob, mixer=mixer, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_set_packing_vqe(self):
""" set packing vqe test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
wavefunction = TwoLocal(rotation_blocks='ry',
entanglement_blocks='cz',
reps=3,
entanglement='linear')
q_i = QuantumInstance(Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = VQE(wavefunction,
SPSA(maxiter=200),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
ising_sol = set_packing.get_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(ising_sol), oracle)
def test_partition(self):
""" Partition test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[])
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_clique(self):
""" Clique test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[])
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_tsp(self):
""" TSP test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op)
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_vertex_cover(self):
""" Vertex Cover test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=[])
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_set_packing(self):
""" set packing test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=[])
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_exact_cover(self):
""" Exact Cover test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[])
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_stable_set(self):
""" Stable set test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(self.qubit_op,
aux_operators=[])
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue.real, -39.5)
self.assertAlmostEqual(result.eigenvalue.real + self.offset, -38.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (4, False))
def _run_knapsack(values, weights, max_weight):
qubit_op, _ = knapsack.get_operator(values, weights, max_weight)
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=qubit_op)
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_partition_vqe(self):
""" Partition VQE test """
algorithm_globals.random_seed = 100
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(RealAmplitudes(reps=5, entanglement='linear'),
SPSA(maxiter=200),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
self.assertNotEqual(x[0], x[1])
self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_graph_partition(self):
""" Graph Partition test """
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(operator=self.qubit_op,
aux_operators=[])
x = sample_most_likely(result.eigenstate)
# check against the oracle
ising_sol = graph_partition.get_graph_solution(x)
# solutions are equivalent
self.assertEqual(
graph_partition.objective_value(np.array([0, 1, 0, 1]), self.w),
graph_partition.objective_value(ising_sol, self.w))
oracle = self._brute_force()
self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
def test_change_operator_size(self):
""" QAOA change operator size test """
aqua_globals.random_seed = 0
qubit_op, _ = max_cut.get_operator(
np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]]))
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa = QAOA(COBYLA(), 1, quantum_instance=q_i)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest(msg='QAOA 4x4'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
{'0101', '1010'})
try:
qubit_op, _ = max_cut.get_operator(
np.array([
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
]))
except Exception as ex: # pylint: disable=broad-except
self.fail("Failed to change operator. Error: '{}'".format(str(ex)))
return
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest(msg='QAOA 6x6'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
{'010101', '101010'})
def test_exact_cover_vqe(self):
""" Exact Cover VQE test """
algorithm_globals.random_seed = 10598
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(EfficientSU2(self.qubit_op.num_qubits, reps=5),
COBYLA(),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
ising_sol = exact_cover.get_solution(x)
oracle = self._brute_force()
self.assertEqual(exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets),
oracle)
def test_clique_vqe(self):
""" VQE Clique test """
aqua_globals.random_seed = 10598
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = VQE(RealAmplitudes(reps=5, entanglement='linear'),
COBYLA(),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(operator=self.qubit_op)
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_stable_set_vqe(self):
""" VQE Stable set test """
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed)
result = VQE(EfficientSU2(reps=3, entanglement='linear'),
L_BFGS_B(maxfun=6000),
quantum_instance=q_i).compute_minimum_eigenvalue(
self.qubit_op)
x = sample_most_likely(result.eigenstate)
self.assertAlmostEqual(result.eigenvalue, -39.5)
self.assertAlmostEqual(result.eigenvalue + self.offset, -38.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 0, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (4.0, False))
def test_vertex_cover_vqe(self):
""" Vertex Cover VQE test """
aqua_globals.random_seed = self.seed
q_i = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = VQE(EfficientSU2(reps=3),
SPSA(maxiter=200),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
sol = vertex_cover.get_graph_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_qaoa_initial_point(self, w, solutions, init_pt):
""" Check first parameter value used is initial point as expected """
aqua_globals.random_seed = 10598
optimizer = COBYLA()
qubit_op, _ = max_cut.get_operator(w)
first_pt = []
def cb_callback(eval_count, parameters, mean, std):
nonlocal first_pt
if eval_count == 1:
first_pt = list(parameters)
quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
qaoa = QAOA(optimizer,
initial_point=init_pt,
callback=cb_callback,
quantum_instance=quantum_instance)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = sample_most_likely(result.eigenstate)
graph_solution = max_cut.get_graph_solution(x)
with self.subTest('Initial Point'):
# If None the preferred random initial point of QAOA variational form
if init_pt is None:
np.testing.assert_almost_equal([-0.2398, 0.3378],
first_pt,
decimal=4)
else:
self.assertListEqual(init_pt, first_pt)
with self.subTest('Solution'):
self.assertIn(''.join([str(int(i)) for i in graph_solution]),
solutions)
def test_graph_partition_vqe(self):
""" Graph Partition VQE test """
aqua_globals.random_seed = 10213
wavefunction = RealAmplitudes(self.qubit_op.num_qubits,
insert_barriers=True,
reps=5,
entanglement='linear')
q_i = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
result = VQE(wavefunction,
SPSA(maxiter=300),
max_evals_grouped=2,
quantum_instance=q_i).compute_minimum_eigenvalue(
operator=self.qubit_op)
x = sample_most_likely(result.eigenstate)
# check against the oracle
ising_sol = graph_partition.get_graph_solution(x)
self.assertEqual(
graph_partition.objective_value(np.array([0, 1, 0, 1]), self.w),
graph_partition.objective_value(ising_sol, self.w))
oracle = self._brute_force()
self.assertEqual(graph_partition.objective_value(x, self.w), oracle)
