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)