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)
