def test_phase_square(self):
S = qc.Phase()
Z = qc.PauliZ()
self.assertLess(
max_absolute_difference(
S(S), Z), epsilon)
def quantum_teleportation(alice_state):
# Get operators we will need
CNOT = qc.CNOT()
H = qc.Hadamard()
X = qc.PauliX()
Z = qc.PauliZ()
# The prepared, shared Bell state
bell = qc.bell_state(0, 0)
# The whole state vector
state = alice_state * bell
# Apply CNOT and Hadamard gate
state = CNOT(state, qubit_indices=[0, 1])
state = H(state, qubit_indices=[0])
# Measure the first two bits
# The only uncollapsed part of the state vector is Bob's
M1, M2 = state.measure(qubit_indices=[0, 1], remove=True)
# Apply X and/or Z gates to third qubit depending on measurements
if M2:
state = X(state)
if M1:
state = Z(state)
return state
def test_hadamard_pauli_identities(self):
X = qc.PauliX()
Y = qc.PauliY()
Z = qc.PauliZ()
H = qc.Hadamard()
self.assertLess(max_absolute_difference(H(X(H)), Z), epsilon)
self.assertLess(max_absolute_difference(H(Z(H)), X), epsilon)
self.assertLess(max_absolute_difference(H(Y(H)), -Y), epsilon)
self.assertLess(max_absolute_difference(X(Y(X)), -Y), epsilon)
def test_rotations_equal_pauli(self):
X = qc.PauliX()
Y = qc.PauliY()
Z = qc.PauliZ()
Rx = qc.RotationX(np.pi)
Ry = qc.RotationY(np.pi)
Rz = qc.RotationZ(np.pi)
self.assertLess(max_absolute_difference(1j * Rx, X), epsilon)
self.assertLess(max_absolute_difference(1j * Ry, Y), epsilon)
self.assertLess(max_absolute_difference(1j * Rz, Z), epsilon)
def test_pauli_identities(self):
X = qc.PauliX()
Y = qc.PauliY()
Z = qc.PauliZ()
self.assertLess(max_absolute_difference(X(Y), 1j * Z), epsilon)
self.assertLess(max_absolute_difference(Y(X), -1j * Z), epsilon)
self.assertLess(max_absolute_difference(Y(Z), 1j * X), epsilon)
self.assertLess(max_absolute_difference(Z(Y), -1j * X), epsilon)
self.assertLess(max_absolute_difference(Z(X), 1j * Y), epsilon)
self.assertLess(max_absolute_difference(X(Z), -1j * Y), epsilon)
def test_hadamard(self):
"""
H = (X + Y)/sqrt(2)
"""
H = qc.Hadamard()
X = qc.PauliX()
Z = qc.PauliZ()
H1 = (X + Z) / np.sqrt(2)
max_diff = max_absolute_difference(H, H1)
self.assertLess(max_diff, epsilon)
H2 = (X + Z) * (1 / np.sqrt(2))
max_diff = max_absolute_difference(H, H2)
self.assertLess(max_diff, epsilon)
H3 = 1 / np.sqrt(2) * (Z + X)
max_diff = max_absolute_difference(H, H3)
self.assertLess(max_diff, epsilon)
self.assertLess(max_absolute_difference(np.sqrt(2) * H - Z, X),
epsilon)
def test_phase_identities(self):
Z = qc.PauliZ()
S = qc.Phase()
T = qc.PiBy8()
H = qc.Hadamard()
self.assertLess(max_absolute_difference(T(T), S), epsilon)
self.assertLess(max_absolute_difference(S(S), Z), epsilon)
self.assertLess(max_absolute_difference(T(T(T(T))), Z), epsilon)
self.assertLess(
max_absolute_difference(
T,
np.exp(1j * np.pi / 8) * qc.RotationZ(np.pi / 4)), epsilon)
self.assertLess(
max_absolute_difference(
S,
np.exp(1j * np.pi / 4) * qc.RotationZ(np.pi / 2)), epsilon)
self.assertLess(
max_absolute_difference(
H(T(H)),
np.exp(1j * np.pi / 8) * qc.RotationX(np.pi / 4)), epsilon)
def superdense_coding(bit_1, bit_2):
# Get operators we will need
CNOT = qc.CNOT()
H = qc.Hadamard()
X = qc.PauliX()
Z = qc.PauliZ()
# The prepared, shared Bell state
# Initially, half is in Alice's possession, and half in Bob's
phi = qc.bell_state(0, 0)
# Alice manipulates her qubit
if bit_2:
phi = X(phi, qubit_indices=[0])
if bit_1:
phi = Z(phi, qubit_indices=[0])
# Bob decodes the two bits
phi = CNOT(phi)
phi = H(phi, qubit_indices=[0])
measurements = phi.measure()
return measurements
