def test_complex_1_qubit_circuit(self): q = QuantumRegister(1) circ = QuantumCircuit(q) circ.append(U3Gate(1, 1, 1), [q[0]]) rho, psi = run_circuit_and_tomography(circ, q, self.method) F_bell = state_fidelity(psi, rho, validate=False) self.assertAlmostEqual(F_bell, 1, places=1)
def test_basis_state_circuit(self): state = state = (basis_state('001', 3)+basis_state('111', 3))/np.sqrt(2) q = QuantumRegister(3) qc = QuantumCircuit(q) qc.initialize(state, [q[0], q[1], q[2]]) backend = BasicAer.get_backend('statevector_simulator') qc_state = execute(qc, backend).result().get_statevector(qc) self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_local_pbasis_default_densitymatrix(self): """Test default states kwarg""" default_states = [qi.random_density_matrix(2, seed=30 + i) for i in range(3)] basis = LocalPreparationBasis("fitter_basis", default_states=default_states) for i, state in enumerate(default_states): basis_state = qi.DensityMatrix(basis.matrix([i], [0])) fid = qi.state_fidelity(state, basis_state) self.assertTrue(isclose(fid, 1))
def test_random_state_circuit(self): state = random_state(2**3, seed=40) q = QuantumRegister(3) qc = QuantumCircuit(q) qc.initialize(state, [q[0], q[1], q[2]]) backend = BasicAer.get_backend('statevector_simulator') qc_state = execute(qc, backend).result().get_statevector(qc) self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_2Q_interaction(self): r"""Test 2 qubit interaction via controlled operations using u channels.""" total_samples = 100 # set coupling term and drive channels to 0 frequency j = 0.5 / total_samples omega_d0 = 0. omega_d1 = 0. system_model = self._system_model_2Q(j) schedule = self._2Q_constant_sched(total_samples) qobj = assemble([schedule], backend=self.backend_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=[omega_d0, omega_d1], memory_slots=2, shots=1) y0 = np.kron(np.array([1., 0.]), np.array([0., 1.])) backend_options = {'seed' : 9000, 'initial_state': y0} result = self.backend_sim.run(qobj, system_model, backend_options).result() pulse_sim_yf = result.get_statevector() # exact analytic solution yf = expm(-1j * 0.5 * 2 * np.pi * np.kron(self.X, self.Z) / 4) @ y0 self.assertGreaterEqual(state_fidelity(pulse_sim_yf, yf), 1 - (10**-5)) # run with different initial state y0 = np.kron(np.array([1., 0.]), np.array([1., 0.])) backend_options = {'seed' : 9000, 'initial_state': y0} result = self.backend_sim.run(qobj, system_model, backend_options).result() pulse_sim_yf = result.get_statevector() # exact analytic solution yf = expm(-1j * 0.5 * 2 * np.pi * np.kron(self.X, self.Z) / 4) @ y0 self.assertGreaterEqual(state_fidelity(pulse_sim_yf, yf), 1 - (10**-5))
def test_state_fidelity_statevector(self): """Test state_fidelity function for statevector inputs""" psi1 = [0.70710678118654746, 0, 0, 0.70710678118654746] psi2 = [0., 0.70710678118654746, 0.70710678118654746, 0.] self.assertAlmostEqual(state_fidelity(psi1, psi1), 1.0, places=7, msg='vector-vector input') self.assertAlmostEqual(state_fidelity(psi2, psi2), 1.0, places=7, msg='vector-vector input') self.assertAlmostEqual(state_fidelity(psi1, psi2), 0.0, places=7, msg='vector-vector input') psi1 = Statevector([0.70710678118654746, 0, 0, 0.70710678118654746]) psi2 = Statevector([0., 0.70710678118654746, 0.70710678118654746, 0.]) self.assertAlmostEqual(state_fidelity(psi1, psi1), 1.0, places=7, msg='vector-vector input') self.assertAlmostEqual(state_fidelity(psi2, psi2), 1.0, places=7, msg='vector-vector input') self.assertAlmostEqual(state_fidelity(psi1, psi2), 0.0, places=7, msg='vector-vector input') psi1 = Statevector([1, 0, 0, 1]) # invalid state psi2 = Statevector([1, 0, 0, 0]) self.assertRaises(QiskitError, state_fidelity, psi1, psi2) self.assertRaises(QiskitError, state_fidelity, psi1, psi2, validate=True) self.assertEqual(state_fidelity(psi1, psi2, validate=False), 1)
def test_state_fidelity_density_matrix(self): """Test state_fidelity function for density matrix inputs""" rho1 = [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]] mix = [[0.25, 0, 0, 0], [0, 0.25, 0, 0], [0, 0, 0.25, 0], [0, 0, 0, 0.25]] self.assertAlmostEqual(state_fidelity(rho1, rho1), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(mix, mix), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(rho1, mix), 0.25, places=7, msg='matrix-matrix input') rho1 = DensityMatrix(rho1) mix = DensityMatrix(mix) self.assertAlmostEqual(state_fidelity(rho1, rho1), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(mix, mix), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(rho1, mix), 0.25, places=7, msg='matrix-matrix input') rho1 = DensityMatrix([1, 0, 0, 0]) mix = DensityMatrix(np.diag([1, 0, 0, 1])) self.assertRaises(QiskitError, state_fidelity, rho1, mix) self.assertRaises(QiskitError, state_fidelity, rho1, mix, validate=True) self.assertEqual(state_fidelity(rho1, mix, validate=False), 1)
def test_different_qubit_sets(self): circuit = QuantumCircuit(5) circuit.h(0) circuit.cx(0, 1) circuit.x(2) circuit.s(3) circuit.z(4) circuit.cx(1, 3) for qubit_pair in [(0, 1), (2, 3), (1, 4), (0, 3)]: rho_cvx, rho_mle, psi = run_circuit_and_tomography( circuit, qubit_pair) psi = partial_trace(psi, [x for x in range(5) if x not in qubit_pair]) F_cvx = state_fidelity(psi, rho_cvx, validate=False) self.assertAlmostEqual(F_cvx, 1, places=1) F_mle = state_fidelity(psi, rho_mle, validate=False) self.assertAlmostEqual(F_mle, 1, places=1)
def test_statevector_density_matrix(self): """Test state_fidelity function for statevector and density matrix inputs""" rho1 = DensityMatrix([[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]) mix = DensityMatrix([[0.25, 0, 0, 0], [0, 0.25, 0, 0], [0, 0, 0.25, 0], [0, 0, 0, 0.25]]) self.assertAlmostEqual(state_fidelity(rho1, rho1), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(mix, mix), 1.0, places=7, msg='matrix-matrix input') self.assertAlmostEqual(state_fidelity(rho1, mix), 0.25, places=7, msg='matrix-matrix input')
def test_random_state(self): # this test that a random state converges to 1/d number = 100000 E_P0_last = 0 for ii in range(number): state = basis_state(bin(3)[2:].zfill(3), 3) E_P0 = (E_P0_last*ii)/(ii+1)+state_fidelity(state, random_state(2**3, seed=ii))/(ii+1) E_P0_last = E_P0 self.assertAlmostEqual(E_P0, 1/8, places=2)
def test_bell_2_qubits(self): q2 = QuantumRegister(2) bell = QuantumCircuit(q2) bell.h(q2[0]) bell.cx(q2[0], q2[1]) rho, psi = run_circuit_and_tomography(bell, q2, self.method) F_bell = state_fidelity(psi, rho, validate=False) self.assertAlmostEqual(F_bell, 1, places=1)
def test_meas_level_1(self): """Test measurement level 1. """ shots = 10000 # run large number of shots for good proportions total_samples = 100 omega_0 = 1. omega_d = omega_0 # Require omega_a*time = pi to implement pi pulse (x gate) # num of samples gives time r = 1. / (2 * total_samples) system_model = self._system_model_1Q(omega_0, r) amp = np.exp(-1j * np.pi / 2) schedule = self._1Q_constant_sched(total_samples, amp=amp) y0=np.array([1.0, 0.0]) pulse_sim = PulseSimulator(system_model=system_model, initial_state=y0, seed=9000) qobj = assemble([schedule], backend=pulse_sim, meas_level=1, meas_return='single', meas_map=[[0]], qubit_lo_freq=[1.], memory_slots=2, shots=shots) result = pulse_sim.run(qobj).result() pulse_sim_yf = result.get_statevector() samples = amp * np.ones((total_samples, 1)) indep_yf = simulate_1q_model(y0, omega_0, r, np.array([omega_d]), samples, 1.) # test final state self.assertGreaterEqual(state_fidelity(pulse_sim_yf, indep_yf), 1 - 10**-5) # Verify that (about) half the IQ vals have abs val 1 and half have abs val 0 # (use prop for easier comparison) mem = np.abs(result.get_memory()[:, 0]) iq_prop = {'0': 0, '1': 0} for i in mem: if i == 0: iq_prop['0'] += 1 / shots else: iq_prop['1'] += 1 / shots exp_prop = {'0': 0.5, '1': 0.5} self.assertDictAlmostEqual(iq_prop, exp_prop, delta=0.01)
def test_qobj_two_qubit_gates(self): filename = self._get_resource_path('qobj/cpp_two_qubit_gates.json') with open(filename, 'r') as file: qobj = Qobj.from_dict(json.load(file)) result = self.backend.run(qobj).result() expected_data = { 'h0 CX01': { 'statevector': np.array([1 / np.sqrt(2), 0, 0, 1 / np.sqrt(2)])}, 'h0 CX10': { 'statevector': np.array([1 / np.sqrt(2), 1 / np.sqrt(2), 0, 0])}, 'h1 CX01': { 'statevector': np.array([1 / np.sqrt(2), 0, 1 / np.sqrt(2), 0])}, 'h1 CX10': { 'statevector': np.array([1 / np.sqrt(2), 0, 0, 1 / np.sqrt(2)])}, 'h0 cx01': { 'statevector': np.array([1 / np.sqrt(2), 0, 0, 1 / np.sqrt(2)])}, 'h0 cx10': { 'statevector': np.array([1 / np.sqrt(2), 1 / np.sqrt(2), 0, 0])}, 'h1 cx01': { 'statevector': np.array([1 / np.sqrt(2), 0, 1 / np.sqrt(2), 0])}, 'h1 cx10': { 'statevector': np.array([1 / np.sqrt(2), 0, 0, 1 / np.sqrt(2)])}, 'h0 cz01': { 'statevector': np.array([1 / np.sqrt(2), 1 / np.sqrt(2), 0, 0])}, 'h0 cz10': { 'statevector': np.array([1 / np.sqrt(2), 1 / np.sqrt(2), 0, 0])}, 'h1 cz01': { 'statevector': np.array([1 / np.sqrt(2), 0, 1 / np.sqrt(2), 0])}, 'h1 cz10': { 'statevector': np.array([1 / np.sqrt(2), 0, 1 / np.sqrt(2), 0])}, 'h0 h1 cz01': {'statevector': np.array([0.5, 0.5, 0.5, -0.5])}, 'h0 h1 cz10': {'statevector': np.array([0.5, 0.5, 0.5, -0.5])}, 'h0 rzz01': { 'statevector': np.array([1 / np.sqrt(2), 1j / np.sqrt(2), 0, 0])}, 'h0 rzz10': { 'statevector': np.array([1 / np.sqrt(2), 1j / np.sqrt(2), 0, 0])}, 'h1 rzz01': { 'statevector': np.array([1 / np.sqrt(2), 0, 1j / np.sqrt(2), 0])}, 'h1 rzz10': { 'statevector': np.array([1 / np.sqrt(2), 0, 1j / np.sqrt(2), 0])}, 'h0 h1 rzz01': {'statevector': np.array([0.5, 0.5j, 0.5j, 0.5])}, 'h0 h1 rzz10': {'statevector': np.array([0.5, 0.5j, 0.5j, 0.5])} } for name in expected_data: # Check snapshot snapshots = result.data(name)['snapshots']['statevector'] self.assertEqual(set(snapshots), {'0'}, msg=name + ' snapshot keys') self.assertEqual(len(snapshots['0']), 1, msg=name + ' snapshot length') state = format_statevector(snapshots['0'][0]) expected_state = expected_data[name]['statevector'] fidelity = state_fidelity(expected_state, state) self.assertAlmostEqual(fidelity, 1.0, places=10, msg=name + ' snapshot fidelity')
def test_basis_state_circuit(self): """TO BE REMOVED with qiskit.quantum_info.basis_state""" with self.assertWarns(DeprecationWarning): state = (basis_state('001', 3) + basis_state('111', 3))/np.sqrt(2) q = QuantumRegister(3) qc = QuantumCircuit(q) qc.initialize(state, [q[0], q[1], q[2]]) backend = BasicAer.get_backend('statevector_simulator') qc_state = execute(qc, backend).result().get_statevector(qc) self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_initialize_qureg_give_int(self, name, a_int): bits = binary.get_required_bits(a_int) qreg = QuantumRegister(bits) qc = QuantumCircuit(qreg) qregs.initialize_qureg_given_int(a_int, qreg, qc) vec = CircuitTestCase.execute_statevector(qc).get_statevector(qc) exp_vec = [0] * (2**bits) exp_vec[a_int] = 1 f = state_fidelity(vec, exp_vec) self.assertAlmostEqual(f, 1)
def test_state_fidelity_mixed(self): """Test state_fidelity function for statevector and density matrix inputs""" psi1 = Statevector([0.70710678118654746, 0, 0, 0.70710678118654746]) rho1 = DensityMatrix([[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]) mix = DensityMatrix([[0.25, 0, 0, 0], [0, 0.25, 0, 0], [0, 0, 0.25, 0], [0, 0, 0, 0.25]]) self.assertAlmostEqual(state_fidelity(psi1, rho1), 1.0, places=7, msg='vector-matrix input') self.assertAlmostEqual(state_fidelity(psi1, mix), 0.25, places=7, msg='vector-matrix input') self.assertAlmostEqual(state_fidelity(rho1, psi1), 1.0, places=7, msg='matrix-vector input')
def test_gaussian_drive(self): """Test gaussian drive pulse using meas_level_2. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time """ # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance total_samples = 100 omega_0 = 1. omega_d = omega_0 # Require omega_a*time = pi to implement pi pulse (x gate) # num of samples gives time r = np.pi / total_samples # initial state and seed y0 = np.array([1., 0.]) seed = 9000 # Test gaussian drive results for a few different sigma gauss_sigmas = [total_samples / 6, total_samples / 3, total_samples] # set up pulse simulator pulse_sim = PulseSimulator(system_model=self._system_model_1Q(omega_0, r)) for gauss_sigma in gauss_sigmas: with self.subTest(gauss_sigma=gauss_sigma): times = 1.0 * np.arange(total_samples) gaussian_samples = np.exp(-times**2 / 2 / gauss_sigma**2) drive_pulse = Waveform(gaussian_samples, name='drive_pulse') # construct schedule schedule = Schedule() schedule |= Play(drive_pulse, DriveChannel(0)) schedule |= Acquire(1, AcquireChannel(0), MemorySlot(0)) << schedule.duration qobj = assemble([schedule], backend=pulse_sim, meas_level=2, meas_return='single', meas_map=[[0]], qubit_lo_freq=[omega_d], memory_slots=2, shots=1) result = pulse_sim.run(qobj, initial_state=y0, seed=seed).result() pulse_sim_yf = result.get_statevector() # run independent simulation yf = simulate_1q_model(y0, omega_0, r, np.array([omega_d]), gaussian_samples, 1.) # Check fidelity of statevectors self.assertGreaterEqual(state_fidelity(pulse_sim_yf, yf), 1 - (10**-5))
def test_random_state_circuit(self): """TO BE REMOVED Run initizalized circuit""" with self.assertWarns(DeprecationWarning): state = random_state(2**3, seed=40) # Initializer test should be elsewhere q = QuantumRegister(3) qc = QuantumCircuit(q) qc.initialize(state, [q[0], q[1], q[2]]) backend = BasicAer.get_backend('statevector_simulator') qc_state = execute(qc, backend).result().get_statevector(qc) self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_random_state(self): """TO BE REMOVED with qiskit.quantum_info.basis_state""" # this test that a random state converges to 1/d number = 1000 E_P0_last = 0 for ii in range(number): with self.assertWarns(DeprecationWarning): state = basis_state(bin(3)[2:].zfill(3), 3) E_P0 = (E_P0_last*ii)/(ii+1)+state_fidelity(state, random_state(2**3, seed=ii))/(ii+1) E_P0_last = E_P0 self.assertAlmostEqual(E_P0, 1/8, places=2)
def test_hhl_negative_eigs(self): """ hhl negative eigs test """ self.log.debug('Testing HHL with matrix with negative eigenvalues') # The following seed was chosen so as to ensure we get a negative eigenvalue # and in case anything changes we assert this after the random matrix is created aqua_globals.random_seed = 27 n = 2 matrix = rmg.random_diag(n, eigrange=[-1, 1]) vector = aqua_globals.random.random(n) self.assertTrue(np.any(matrix < 0), "Random matrix has no negative values") # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result.solution ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 4, True) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = QuantumCircuit(num_q) init_state.initialize(vector / np.linalg.norm(vector), range(num_q)) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) hhl_solution = hhl_result.solution hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=3) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_normed) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result.probability_result)
def _hhl_results(self, vec): self._ret["output_hhl"] = vec # Calculating the fidelity with the classical solution theo = np.linalg.solve(self._matrix, self._vector) theo = theo/np.linalg.norm(theo) self._ret["fidelity_hhl_to_classical"] = state_fidelity(theo, vec) # Rescaling the output vector to the real solution vector tmp_vec = self._matrix.dot(vec) f1 = np.linalg.norm(self._vector)/np.linalg.norm(tmp_vec) f2 = sum(np.angle(self._vector*tmp_vec.conj()-1+1))/self._num_q # "-1+1" to fix angle error for -0.-0.j self._ret["solution_hhl"] = f1*vec*np.exp(-1j*f2)
def test_local_mbasis_default_unitary(self): """Test default povms kwarg""" default_povms = [qi.random_unitary(2, seed=30 + i) for i in range(3)] basis = LocalMeasurementBasis("fitter_basis", default_povms=default_povms) for i, povm in enumerate(default_povms): adjoint = povm.adjoint() for outcome in range(2): state = qi.Statevector.from_int(outcome, dims=2**adjoint.num_qubits) state = state.evolve(adjoint) basis_state = qi.DensityMatrix(basis.matrix([i], outcome, [0])) fid = qi.state_fidelity(state, basis_state) self.assertTrue(isclose(fid, 1))
def test_single_qubit(self): desired_vector = [1 / math.sqrt(3), math.sqrt(2) / math.sqrt(3)] qr = QuantumRegister(1, "qr") qc = QuantumCircuit(qr) qc.initialize(desired_vector, [qr[0]]) job = execute(qc, BasicAer.get_backend('statevector_simulator')) result = job.result() statevector = result.get_statevector() fidelity = state_fidelity(statevector, desired_vector) self.assertGreater( fidelity, self._desired_fidelity, "Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_deterministic_state(self): desired_vector = [0, 1, 0, 0] qr = QuantumRegister(2, "qr") qc = QuantumCircuit(qr) qc.initialize(desired_vector, [qr[0], qr[1]]) job = execute(qc, BasicAer.get_backend('statevector_simulator')) result = job.result() statevector = result.get_statevector() fidelity = state_fidelity(statevector, desired_vector) self.assertGreater( fidelity, self._desired_fidelity, "Initializer has low fidelity {0:.2g}.".format(fidelity))
def _compare_outcomes(self, circ): Provider = QCGPUProvider() backend_qcgpu = Provider.get_backend('statevector_simulator') statevector_qcgpu = execute(circ, backend_qcgpu).result().get_statevector() backend_qiskit = BasicAer.get_backend('statevector_simulator') statevector_qiskit = execute( circ, backend_qiskit).result().get_statevector() self.assertAlmostEqual( state_fidelity(statevector_qcgpu, statevector_qiskit), 1, 5)
def test_uniform_superposition(self): desired_vector = [0.5, 0.5, 0.5, 0.5] qr = QuantumRegister(2, "qr") qc = QuantumCircuit(qr) qc.initialize(desired_vector, [qr[0], qr[1]]) job = execute(qc, Aer.get_backend('statevector_simulator_py')) result = job.result() statevector = result.get_statevector() fidelity = state_fidelity(statevector, desired_vector) self.assertGreater( fidelity, self._desired_fidelity, "Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_ghz_state(self): desired_vector = [1/math.sqrt(2), 0, 0, 0, 0, 0, 0, 1/math.sqrt(2)] qr = QuantumRegister(3, "qr") qc = QuantumCircuit(qr) qc.initialize(desired_vector, [qr[0], qr[1], qr[2]]) job = execute(qc, Aer.get_backend('statevector_simulator_py')) result = job.result() statevector = result.get_statevector() fidelity = state_fidelity(statevector, desired_vector) self.assertGreater( fidelity, self._desired_fidelity, "Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_mixed_batch_exp(self): """Test batch state and process tomography experiment""" # Subsystem unitaries state_op = qi.random_unitary(2, seed=321) chan_op = qi.random_unitary(2, seed=123) state_target = qi.Statevector(state_op.to_instruction()) chan_target = qi.Choi(chan_op.to_instruction()) state_exp = StateTomography(state_op) chan_exp = ProcessTomography(chan_op) batch_exp = BatchExperiment([state_exp, chan_exp]) # Run batch experiments backend = AerSimulator(seed_simulator=9000) par_data = batch_exp.run(backend) self.assertExperimentDone(par_data) f_threshold = 0.95 # Check state tomo results state_results = par_data.child_data(0).analysis_results() state = filter_results(state_results, "state").value # Check fit state fidelity state_fid = filter_results(state_results, "state_fidelity").value self.assertGreater(state_fid, f_threshold, msg="fit fidelity is low") # Manually check fidelity target_fid = qi.state_fidelity(state, state_target, validate=False) self.assertAlmostEqual(state_fid, target_fid, places=6, msg="result fidelity is incorrect") # Check process tomo results chan_results = par_data.child_data(1).analysis_results() chan = filter_results(chan_results, "state").value # Check fit process fidelity chan_fid = filter_results(chan_results, "process_fidelity").value self.assertGreater(chan_fid, f_threshold, msg="fit fidelity is low") # Manually check fidelity target_fid = qi.process_fidelity(chan, chan_target, require_cp=False, require_tp=False) self.assertAlmostEqual(chan_fid, target_fid, places=6, msg="result fidelity is incorrect")
def test_hhl_diagonal(self, vector, use_circuit_library): """ hhl diagonal test """ self.log.debug( 'Testing HHL simple test in mode Lookup with statevector simulator' ) matrix = [[1, 0], [0, 1]] # run NumPyLSsolver ref_result = NumPyLSsolver(matrix, vector).run() ref_solution = ref_result['solution'] ref_normed = ref_solution / np.linalg.norm(ref_solution) # run hhl orig_size = len(vector) matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize( matrix, vector) # Initialize eigenvalue finding module eigs = TestHHL._create_eigs(matrix, 3, False, use_circuit_library) num_q, num_a = eigs.get_register_sizes() # Initialize initial state module init_state = Custom(num_q, state_vector=vector) # Initialize reciprocal rotation module reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time) algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs, init_state, reci, num_q, num_a, orig_size) if not use_circuit_library: warnings.filterwarnings('ignore', category=DeprecationWarning) hhl_result = algo.run( QuantumInstance(BasicAer.get_backend('statevector_simulator'), seed_simulator=aqua_globals.random_seed, seed_transpiler=aqua_globals.random_seed)) if not use_circuit_library: warnings.filterwarnings('always', category=DeprecationWarning) hhl_solution = hhl_result['solution'] hhl_normed = hhl_solution / np.linalg.norm(hhl_solution) # compare results fidelity = state_fidelity(ref_normed, hhl_normed) np.testing.assert_approx_equal(fidelity, 1, significant=5) self.log.debug('HHL solution vector: %s', hhl_solution) self.log.debug('algebraic solution vector: %s', ref_solution) self.log.debug('fidelity HHL to algebraic: %s', fidelity) self.log.debug('probability of result: %s', hhl_result["probability_result"])
def test_complex_3_qubit_circuit(self): def rand_angles(): # pylint: disable=E1101 return tuple(2 * numpy.pi * numpy.random.random(3) - numpy.pi) q = QuantumRegister(3) circ = QuantumCircuit(q) for j in range(3): circ.u3(*rand_angles(), q[j]) rho, psi = run_circuit_and_tomography(circ, q, self.method) F_bell = state_fidelity(psi, rho, validate=False) self.assertAlmostEqual(F_bell, 1, places=1)
def _run(self): evo_time = 1 # get the groundtruth via simple matrix * vector state_out_exact = self._operator.evolve(self._initial_state.construct_circuit('vector'), evo_time, 'matrix', 0) qr = QuantumRegister(self._operator.num_qubits, name='q') circuit = self._initial_state.construct_circuit('circuit', qr) circuit += self._operator.evolve( None, evo_time, 'circuit', 1, quantum_registers=qr, expansion_mode='suzuki', expansion_order=self._expansion_order ) result = self._quantum_instance.execute(circuit) state_out_dynamics = np.asarray(result.get_statevector(circuit)) self._ret['score'] = state_fidelity(state_out_exact, state_out_dynamics) return self._ret