def test_basis(self): # reference state = basis_state('010', 3) state_ideal = np.array([ 0. + 0.j, 0. + 0.j, 1. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j, 0. + 0.j ]) state_fidelity(state, state_ideal) self.assertEqual(state_fidelity(state, state_ideal), 1.0)
def test_qasm_snapshot(self): """snapshot a circuit at multiple places""" qr = qiskit.QuantumRegister(3) cr = qiskit.ClassicalRegister(3) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) circuit.snapshot(1) circuit.ccx(qr[0], qr[1], qr[2]) circuit.snapshot(2) circuit.reset(qr) circuit.snapshot(3) circuit.measure(qr, cr) sim_cpp = Aer.get_backend('qasm_simulator') sim_py = Aer.get_backend('qasm_simulator_py') result_cpp = execute(circuit, sim_cpp, shots=2).result() result_py = execute(circuit, sim_py, shots=2).result() snapshots_cpp = result_cpp.get_snapshots() snapshots_py = result_py.get_snapshots() self.assertEqual(snapshots_cpp.keys(), snapshots_py.keys()) snapshot_cpp_1 = result_cpp.get_snapshot(slot='1') snapshot_py_1 = result_py.get_snapshot(slot='1') self.assertEqual(len(snapshot_cpp_1), len(snapshot_py_1)) fidelity = state_fidelity(snapshot_cpp_1[0], snapshot_py_1[0]) self.assertGreater(fidelity, self._desired_fidelity)
def test_combine_circuit_extension_instructions(self): """Test combining circuits containing barrier, initializer, snapshot """ qr = QuantumRegister(2) cr = ClassicalRegister(2) qc1 = QuantumCircuit(qr) desired_vector = [0.5, 0.5, 0.5, 0.5] qc1.initialize(desired_vector, qr) qc1.barrier() qc2 = QuantumCircuit(qr, cr) qc2.snapshot(slot='1') qc2.measure(qr, cr) new_circuit = qc1 + qc2 backend = Aer.get_backend('qasm_simulator_py') shots = 1024 result = execute(new_circuit, backend=backend, shots=shots, seed=78).result() snapshot_vectors = result.get_snapshot() fidelity = state_fidelity(snapshot_vectors[0], desired_vector) self.assertGreater(fidelity, 0.99) counts = result.get_counts() target = { '00': shots / 4, '01': shots / 4, '10': shots / 4, '11': shots / 4 } threshold = 0.04 * shots self.assertDictAlmostEqual(counts, target, threshold)
def test_mcmt_v_chain_simulation(self, cgate, num_controls, num_targets): """Test the MCMT V-chain implementation test on a simulation.""" controls = QuantumRegister(num_controls) targets = QuantumRegister(num_targets) subsets = [tuple(range(i)) for i in range(num_controls + 1)] for subset in subsets: qc = QuantumCircuit(targets, controls) # Initialize all targets to 1, just to be sure that # the generic gate has some effect (f.e. Z gate has no effect # on a 0 state) qc.x(targets) num_ancillas = max(0, num_controls - 1) if num_ancillas > 0: ancillas = QuantumRegister(num_ancillas) qc.add_register(ancillas) qubits = controls[:] + targets[:] + ancillas[:] else: qubits = controls[:] + targets[:] for i in subset: qc.x(controls[i]) mcmt = MCMTVChain(cgate, num_controls, num_targets) qc.compose(mcmt, qubits, inplace=True) for i in subset: qc.x(controls[i]) vec = Statevector.from_label("0" * qc.num_qubits).evolve(qc) # target register is initially |11...1>, with length equal to 2**(n_targets) vec_exp = np.array([0] * (2 ** (num_targets) - 1) + [1]) if isinstance(cgate, CZGate): # Z gate flips the last qubit only if it's applied an odd number of times if len(subset) == num_controls and (num_controls % 2) == 1: vec_exp[-1] = -1 elif isinstance(cgate, CHGate): # if all the control qubits have been activated, # we repeatedly apply the kronecker product of the Hadamard # with itself and then multiply the results for the original # state of the target qubits if len(subset) == num_controls: h_i = 1 / np.sqrt(2) * np.array([[1, 1], [1, -1]]) h_tot = np.array([1]) for _ in range(num_targets): h_tot = np.kron(h_tot, h_i) vec_exp = np.dot(h_tot, vec_exp) else: raise ValueError(f"Test not implement for gate: {cgate}") # append the remaining part of the state vec_exp = np.concatenate( (vec_exp, [0] * (2 ** (num_controls + num_ancillas + num_targets) - vec_exp.size)) ) f_i = state_fidelity(vec, vec_exp) self.assertAlmostEqual(f_i, 1)
def test_random_state_circuit(self): state = random_state(3) q = QuantumRegister(3) qc = QuantumCircuit(q) qc.initialize(state, [q[0], q[1], q[2]]) backend = Aer.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): # 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(np.random.randint(0, 8))[2:].zfill(3), 3) E_P0 = (E_P0_last * ii) / (ii + 1) + state_fidelity( state, random_state(3)) / (ii + 1) E_P0_last = E_P0 self.assertAlmostEqual(E_P0, 1 / 8, places=2)
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, Aer.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, Aer.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_state_fidelity(self): psi1 = [0.70710678118654746, 0, 0, 0.70710678118654746] psi2 = [0., 0.70710678118654746, 0.70710678118654746, 0.] 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(psi1, psi1), 1.0, places=7, msg='vector-vector input') self.assertAlmostEqual(state_fidelity(psi1, psi2), 0.0, places=7, msg='vector-vector input') 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(psi2, rho1), 0.0, places=7, msg='vector-matrix input') self.assertAlmostEqual(state_fidelity(psi2, mix), 0.25, places=7, msg='vector-matrix input') self.assertAlmostEqual(state_fidelity(rho1, psi1), 1.0, places=7, msg='matrix-vector input') 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')
def test_combiner(self): desired_vector = [0, 1] qr = QuantumRegister(1, "qr") cr = ClassicalRegister(1, "cr") qc1 = QuantumCircuit(qr, cr) qc1.initialize([1.0 / math.sqrt(2), 1.0 / math.sqrt(2)], [qr[0]]) qc2 = QuantumCircuit(qr, cr) qc2.initialize([1.0 / math.sqrt(2), -1.0 / math.sqrt(2)], [qr[0]]) job = execute(qc1 + qc2, Aer.get_backend('statevector_simulator')) result = job.result() quantum_state = result.get_statevector() fidelity = state_fidelity(quantum_state, desired_vector) self.assertGreater( fidelity, self._desired_fidelity, "Initializer has low fidelity {0:.2g}.".format(fidelity))
def test_statevector(self): """statevector from a bell state""" qr = qiskit.QuantumRegister(2) circuit = qiskit.QuantumCircuit(qr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) sim_cpp = Aer.get_backend('statevector_simulator') sim_py = Aer.get_backend('statevector_simulator_py') result_cpp = execute(circuit, sim_cpp).result() result_py = execute(circuit, sim_py).result() statevector_cpp = result_cpp.get_statevector() statevector_py = result_py.get_statevector() fidelity = state_fidelity(statevector_cpp, statevector_py) self.assertGreater( fidelity, self._desired_fidelity, "cpp vs. py statevector has low fidelity{0:.2g}.".format(fidelity))
def test_random_4qubit(self): desired_vector = [ 1 / math.sqrt(4) * complex(0, 1), 1 / math.sqrt(8) * complex(1, 0), 0, 0, 0, 0, 0, 0, 1 / math.sqrt(8) * complex(1, 0), 1 / math.sqrt(8) * complex(0, 1), 0, 0, 0, 0, 1 / math.sqrt(4) * complex(1, 0), 1 / math.sqrt(8) * complex(1, 0) ] qr = QuantumRegister(4, "qr") qc = QuantumCircuit(qr) qc.initialize(desired_vector, [qr[0], qr[1], qr[2], qr[3]]) job = execute(qc, Aer.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_snapshot(self): """snapshot a bell state in the middle of circuit""" qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.cx(qr[0], qr[1]) circuit.snapshot(3) circuit.cx(qr[0], qr[1]) circuit.h(qr[1]) sim = Aer.get_backend('statevector_simulator') result = execute(circuit, sim).result() snapshot = result.get_snapshot(slot='3') target = [0.70710678 + 0.j, 0. + 0.j, 0. + 0.j, 0.70710678 + 0.j] fidelity = state_fidelity(snapshot, target) self.assertGreater( fidelity, self._desired_fidelity, "snapshot has low fidelity{0:.2g}.".format(fidelity))
def test_save_load(self): """save |+>|0>, do some stuff, then load""" qr = qiskit.QuantumRegister(2) cr = qiskit.ClassicalRegister(2) circuit = qiskit.QuantumCircuit(qr, cr) circuit.h(qr[0]) circuit.save(1) circuit.cx(qr[0], qr[1]) circuit.cx(qr[1], qr[0]) circuit.h(qr[1]) circuit.load(1) sim = Aer.get_backend('statevector_simulator') result = execute(circuit, sim).result() statevector = result.get_statevector() target = [0.70710678 + 0.j, 0.70710678 + 0.j, 0. + 0.j, 0. + 0.j] fidelity = state_fidelity(statevector, target) self.assertGreater( fidelity, self._desired_fidelity, "save-load statevector has low fidelity{0:.2g}.".format(fidelity))
def fidelity(vec1, vec2): sv1 = Statevector(vec1) sv2 = Statevector(vec2) return state_fidelity(sv1, sv2)
def test_projector(self): state0 = np.array([1. + 0.j, 0. + 0.j]) state1 = projector(np.array([0. + 0.j, 1. + 0.j])) self.assertEqual(state_fidelity(state0, state0), 1.0) self.assertEqual(state_fidelity(state1, state1), 1.0) self.assertEqual(state_fidelity(state0, state1), 0.0)
def test_state_fidelity_qubit(self): state0 = np.array([1. + 0.j, 0. + 0.j]) state1 = np.array([0. + 0.j, 1. + 0.j]) self.assertEqual(state_fidelity(state0, state0), 1.0) self.assertEqual(state_fidelity(state1, state1), 1.0) self.assertEqual(state_fidelity(state0, state1), 0.0)