def test_qpe_Xplus(self, state): """eigenproblem X, |+>""" unitary_circuit = X.to_circuit() if state == 'minus': # prepare |-> state_preparation = X.to_circuit() state_preparation.h(0) else: # prepare |+> state_preparation = H.to_circuit() phase = self.one_phase(unitary_circuit, state_preparation) if state == 'minus': self.assertEqual(phase, 0.5) else: self.assertEqual(phase, 0.0)
def test_check_num_iterations(self): """test check for num_iterations greater than zero""" unitary_circuit = X.to_circuit() state_preparation = None with self.assertRaises(ValueError): self.one_phase(unitary_circuit, state_preparation, num_iterations=-1)
def test_qpe_X_plus_minus(self, state_preparation, expected_phase, phase_estimator): """eigenproblem X, (|+>, |->)""" unitary_circuit = X.to_circuit() phase = self.one_phase(unitary_circuit, state_preparation, phase_estimator=phase_estimator) self.assertEqual(phase, expected_phase)
def test_qpe_Z1(self, backend_type): """eigenproblem Z, |1>""" backend = qiskit.BasicAer.get_backend(backend_type) unitary_circuit = Z.to_circuit() state_preparation = X.to_circuit() # prepare |1> phase = self.one_phase(unitary_circuit, state_preparation, backend=backend) self.assertEqual(phase, 0.5)
def test_single_pauli_op(self): """Two eigenvalues from Pauli sum with X, Y, Z""" hamiltonian = Z state_preparation = None result = self.hamiltonian_pe(hamiltonian, state_preparation, evolution=None) eigv = result.most_likely_eigenvalue with self.subTest("First eigenvalue"): self.assertAlmostEqual(eigv, 1.0, delta=0.001) state_preparation = StateFn(X.to_circuit()) result = self.hamiltonian_pe(hamiltonian, state_preparation, bound=1.05) eigv = result.most_likely_eigenvalue with self.subTest("Second eigenvalue"): self.assertAlmostEqual(eigv, -0.98, delta=0.01)
class TestPhaseEstimation(QiskitAlgorithmsTestCase): """Evolution tests.""" # pylint: disable=invalid-name def one_phase( self, unitary_circuit, state_preparation=None, backend_type=None, phase_estimator=None, num_iterations=6, ): """Run phase estimation with operator, eigenvalue pair `unitary_circuit`, `state_preparation`. Return the estimated phase as a value in :math:`[0,1)`. """ if backend_type is None: backend_type = "qasm_simulator" backend = qiskit.BasicAer.get_backend(backend_type) qi = qiskit.utils.QuantumInstance(backend=backend, shots=10000) if phase_estimator is None: phase_estimator = IterativePhaseEstimation if phase_estimator == IterativePhaseEstimation: p_est = IterativePhaseEstimation(num_iterations=num_iterations, quantum_instance=qi) elif phase_estimator == PhaseEstimation: p_est = PhaseEstimation(num_evaluation_qubits=6, quantum_instance=qi) else: raise ValueError("Unrecognized phase_estimator") result = p_est.estimate(unitary=unitary_circuit, state_preparation=state_preparation) phase = result.phase return phase @data( (X.to_circuit(), 0.5, "statevector_simulator", IterativePhaseEstimation), (X.to_circuit(), 0.5, "qasm_simulator", IterativePhaseEstimation), (None, 0.0, "qasm_simulator", IterativePhaseEstimation), (X.to_circuit(), 0.5, "qasm_simulator", PhaseEstimation), (None, 0.0, "qasm_simulator", PhaseEstimation), (X.to_circuit(), 0.5, "statevector_simulator", PhaseEstimation), ) @unpack def test_qpe_Z(self, state_preparation, expected_phase, backend_type, phase_estimator): """eigenproblem Z, |0> and |1>""" unitary_circuit = Z.to_circuit() phase = self.one_phase( unitary_circuit, state_preparation, backend_type=backend_type, phase_estimator=phase_estimator, ) self.assertEqual(phase, expected_phase) @data( (H.to_circuit(), 0.0, IterativePhaseEstimation), ((H @ X).to_circuit(), 0.5, IterativePhaseEstimation), (H.to_circuit(), 0.0, PhaseEstimation), ((H @ X).to_circuit(), 0.5, PhaseEstimation), ) @unpack def test_qpe_X_plus_minus(self, state_preparation, expected_phase, phase_estimator): """eigenproblem X, (|+>, |->)""" unitary_circuit = X.to_circuit() phase = self.one_phase(unitary_circuit, state_preparation, phase_estimator=phase_estimator) self.assertEqual(phase, expected_phase) @data( (X.to_circuit(), 0.125, IterativePhaseEstimation), (I.to_circuit(), 0.875, IterativePhaseEstimation), (X.to_circuit(), 0.125, PhaseEstimation), (I.to_circuit(), 0.875, PhaseEstimation), ) @unpack def test_qpe_RZ(self, state_preparation, expected_phase, phase_estimator): """eigenproblem RZ, (|0>, |1>)""" alpha = np.pi / 2 unitary_circuit = QuantumCircuit(1) unitary_circuit.rz(alpha, 0) phase = self.one_phase(unitary_circuit, state_preparation, phase_estimator=phase_estimator) self.assertEqual(phase, expected_phase) def test_check_num_iterations(self): """test check for num_iterations greater than zero""" unitary_circuit = X.to_circuit() state_preparation = None with self.assertRaises(ValueError): self.one_phase(unitary_circuit, state_preparation, num_iterations=-1) def phase_estimation( self, unitary_circuit, state_preparation=None, num_evaluation_qubits=6, backend=None, construct_circuit=False, ): """Run phase estimation with operator, eigenvalue pair `unitary_circuit`, `state_preparation`. Return all results """ if backend is None: backend = qiskit.BasicAer.get_backend("statevector_simulator") qi = qiskit.utils.QuantumInstance(backend=backend, shots=10000) phase_est = PhaseEstimation( num_evaluation_qubits=num_evaluation_qubits, quantum_instance=qi) if construct_circuit: pe_circuit = phase_est.construct_circuit(unitary_circuit, state_preparation) result = phase_est.estimate_from_pe_circuit( pe_circuit, unitary_circuit.num_qubits) else: result = phase_est.estimate(unitary=unitary_circuit, state_preparation=state_preparation) return result @data(True, False) def test_qpe_Zplus(self, construct_circuit): """superposition eigenproblem Z, |+>""" unitary_circuit = Z.to_circuit() state_preparation = H.to_circuit() # prepare |+> result = self.phase_estimation( unitary_circuit, state_preparation, backend=qiskit.BasicAer.get_backend("statevector_simulator"), construct_circuit=construct_circuit, ) phases = result.filter_phases(1e-15, as_float=True) with self.subTest("test phases has correct values"): self.assertEqual(list(phases.keys()), [0.0, 0.5]) with self.subTest("test phases has correct probabilities"): np.testing.assert_allclose(list(phases.values()), [0.5, 0.5]) with self.subTest("test bitstring representation"): phases = result.filter_phases(1e-15, as_float=False) self.assertEqual(list(phases.keys()), ["000000", "100000"])