def test_inner_product():
# also tested via test_gate_angle
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
hs = qf.asarray(qf.inner_product(qf.RX(theta).vec, qf.RX(theta).vec))
print('RX({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(qf.inner_product(qf.RZ(theta).vec, qf.RZ(theta).vec))
print('RZ({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(qf.inner_product(qf.RY(theta).vec, qf.RY(theta).vec))
print('RY({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(
qf.inner_product(qf.PSWAP(theta).vec,
qf.PSWAP(theta).vec))
print('PSWAP({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 4 == ALMOST_ONE
with pytest.raises(ValueError):
qf.inner_product(qf.zero_state(0).vec, qf.X(0).vec)
with pytest.raises(ValueError):
qf.inner_product(qf.CNOT(0, 1).vec, qf.X(0).vec)
def test_parametric_gates1():
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
assert qf.almost_unitary(qf.RX(theta))
assert qf.almost_unitary(qf.RY(theta))
assert qf.almost_unitary(qf.RZ(theta))
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
assert qf.almost_unitary(qf.TX(theta))
assert qf.almost_unitary(qf.TY(theta))
assert qf.almost_unitary(qf.TZ(theta))
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
assert qf.almost_unitary(qf.CPHASE00(theta))
assert qf.almost_unitary(qf.CPHASE01(theta))
assert qf.almost_unitary(qf.CPHASE10(theta))
assert qf.almost_unitary(qf.CPHASE(theta))
assert qf.almost_unitary(qf.PSWAP(theta))
assert qf.gates_close(qf.I(), qf.I())
assert qf.gates_close(qf.RX(pi), qf.X())
assert qf.gates_close(qf.RY(pi), qf.Y())
assert qf.gates_close(qf.RZ(pi), qf.Z())
def test_RN():
for _ in range(REPS):
theta = random.uniform(-2 * pi, +2 * pi)
nx = random.uniform(0, 1)
ny = random.uniform(0, 1)
nz = random.uniform(0, 1)
L = np.sqrt(nx**2 + ny**2 + nz**2)
nx /= L
ny /= L
nz /= L
gate = qf.RN(theta, nx, ny, nz)
assert qf.almost_unitary(gate)
gate2 = qf.RN(-theta, nx, ny, nz)
assert qf.gates_close(gate.H, gate2)
assert qf.gates_close(gate**-1, gate2)
theta = 1.23
gate = qf.RN(theta, 1, 0, 0)
assert qf.gates_close(gate, qf.RX(theta))
gate = qf.RN(theta, 0, 1, 0)
assert qf.gates_close(gate, qf.RY(theta))
gate = qf.RN(theta, 0, 0, 1)
assert qf.gates_close(gate, qf.RZ(theta))
gate = qf.RN(pi, np.sqrt(2), 0, np.sqrt(2))
assert qf.gates_close(gate, qf.H())
def test_biased_coin():
# sample from a 75% head and 25% tails coin
rho = qf.zero_state(1).asdensity()
chan = qf.RX(np.pi / 3, 0).aschannel()
rho = chan.evolve(rho)
prob = qf.asarray(rho.probabilities())
assert np.allclose(prob, [0.75, 0.25])
def test_fubini_study_angle_states():
# The state angle is half angle in Bloch sphere
angle1 = 0.1324
ket1 = qf.zero_state(1)
ket2 = qf.RX(angle1, 0).run(ket1)
angle2 = qf.asarray(qf.fubini_study_angle(ket1.vec, ket2.vec))
assert angle1 - angle2 * 2 == ALMOST_ZERO
def test_fubini_study_angle():
for _ in range(REPS):
theta = random.uniform(-pi, +pi)
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RX(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RY(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RZ(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(
qf.fubini_study_angle(qf.SWAP().vec,
qf.PSWAP(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec,
qf.PHASE(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
for n in range(1, 6):
eye = qf.identity_gate(n)
assert qf.asarray(qf.fubini_study_angle(eye.vec, eye.vec)) \
== ALMOST_ZERO
with pytest.raises(ValueError):
qf.fubini_study_angle(qf.random_gate(1).vec, qf.random_gate(2).vec)
def test_hadamard():
gate = qf.I()
gate = qf.RZ(pi / 2, 0) @ gate
gate = qf.RX(pi / 2, 0) @ gate
gate = qf.RZ(pi / 2, 0) @ gate
res = qf.asarray(qf.inner_product(gate.vec, qf.H().vec))
assert abs(res) / 2 == ALMOST_ONE
def test_gates_to_latex():
circ = qf.Circuit()
circ += qf.I(7)
circ += qf.X(0)
circ += qf.Y(1)
circ += qf.Z(2)
circ += qf.H(3)
circ += qf.S(4)
circ += qf.T(5)
circ += qf.S_H(6)
circ += qf.T_H(7)
circ += qf.RX(-0.5*pi, 0)
circ += qf.RY(0.5*pi, 1)
circ += qf.RZ((1/3)*pi, 1)
circ += qf.RY(0.222, 1)
circ += qf.TX(0.5, 0)
circ += qf.TY(0.5, 1)
circ += qf.TZ(0.4, 1)
circ += qf.TZ(0.47276, 1)
# Gate with cunning hack
gate = qf.RZ(0.4, 1)
gate.params['theta'] = qf.Parameter('\\theta')
circ += gate
circ += qf.CNOT(1, 2)
circ += qf.CNOT(2, 1)
circ += qf.CZ(1, 3)
circ += qf.SWAP(1, 5)
circ += qf.ISWAP(4, 2)
# circ += qf.Barrier(0, 1, 2, 3, 4, 5, 6) # Not yet supported
circ += qf.CCNOT(1, 2, 3)
circ += qf.CSWAP(4, 5, 6)
circ += qf.P0(0)
circ += qf.P1(1)
circ += qf.Reset(2)
circ += qf.Reset(4, 5, 6)
circ += qf.H(4)
# circ += qf.Reset() # FIXME. Should fail with clear error message
circ += qf.XX(0.25, 1, 3)
circ += qf.YY(0.75, 1, 3)
circ += qf.ZZ(1/3, 3, 1)
circ += qf.Measure(0)
latex = qf.circuit_to_latex(circ)
print(latex)
def test_circuit_to_pyquil():
circ = qf.Circuit()
circ += qf.X(0)
prog = qf.forest.circuit_to_pyquil(circ)
assert str(prog) == "X 0\n"
circ = qf.Circuit()
circ1 = qf.Circuit()
circ2 = qf.Circuit()
circ1 += qf.RY(pi/2, 0)
circ1 += qf.RX(pi, 0)
circ1 += qf.RY(pi/2, 1)
circ1 += qf.RX(pi, 1)
circ1 += qf.CNOT(0, 1)
circ2 += qf.RX(-pi/2, 1)
circ2 += qf.RY(4.71572463191, 1)
circ2 += qf.RX(pi/2, 1)
circ2 += qf.CNOT(0, 1)
circ2 += qf.RX(-2*2.74973750579, 0)
circ2 += qf.RX(-2*2.74973750579, 1)
circ.extend(circ1)
circ.extend(circ2)
prog = qf.forest.circuit_to_pyquil(circ)
print(prog)
assert QUILPROG == str(prog)
def test_repr():
g = qf.H()
assert str(g) == 'H 0'
g = qf.RX(3.12)
assert str(g) == 'RX(3.12) 0'
g = qf.identity_gate(2)
assert str(g) == 'I 0 1'
g = qf.random_gate(4)
assert str(g) == 'RAND4 0 1 2 3'
g = qf.H(0)
assert str(g) == 'H 0'
g = qf.CNOT(0, 1)
assert str(g) == 'CNOT 0 1'
g = qf.Gate(qf.CNOT().tensor)
assert str(g).startswith('<quantumflow.ops.Gate')
def test_qaoa_circuit():
circ = qf.Circuit()
circ += qf.RY(pi / 2, 0)
circ += qf.RX(pi, 0)
circ += qf.RY(pi / 2, 1)
circ += qf.RX(pi, 1)
circ += qf.CNOT(0, 1)
circ += qf.RX(-pi / 2, 1)
circ += qf.RY(4.71572463191, 1)
circ += qf.RX(pi / 2, 1)
circ += qf.CNOT(0, 1)
circ += qf.RX(-2 * 2.74973750579, 0)
circ += qf.RX(-2 * 2.74973750579, 1)
ket = qf.zero_state(2)
ket = circ.run(ket)
assert qf.states_close(ket, true_ket())
def test_qaoa():
ket_true = [
0.00167784 + 1.00210180e-05 * 1j, 0.5 - 4.99997185e-01 * 1j,
0.5 - 4.99997185e-01 * 1j, 0.00167784 + 1.00210180e-05 * 1j
]
rho_true = qf.State(ket_true).asdensity()
rho = qf.zero_state(2).asdensity()
rho = qf.RY(pi / 2, 0).aschannel().evolve(rho)
rho = qf.RX(pi, 0).aschannel().evolve(rho)
rho = qf.RY(pi / 2, 1).aschannel().evolve(rho)
rho = qf.RX(pi, 1).aschannel().evolve(rho)
rho = qf.CNOT(0, 1).aschannel().evolve(rho)
rho = qf.RX(-pi / 2, 1).aschannel().evolve(rho)
rho = qf.RY(4.71572463191, 1).aschannel().evolve(rho)
rho = qf.RX(pi / 2, 1).aschannel().evolve(rho)
rho = qf.CNOT(0, 1).aschannel().evolve(rho)
rho = qf.RX(-2 * 2.74973750579, 0).aschannel().evolve(rho)
rho = qf.RX(-2 * 2.74973750579, 1).aschannel().evolve(rho)
assert qf.densities_close(rho, rho_true)
def test_qubit_qaoa_circuit():
# Adapted from reference QVM
wf_true = np.array([
0.00167784 + 1.00210180e-05 * 1j, 0.50000000 - 4.99997185e-01 * 1j,
0.50000000 - 4.99997185e-01 * 1j, 0.00167784 + 1.00210180e-05 * 1j
])
ket_true = qf.State(wf_true.reshape((2, 2)))
ket = qf.zero_state(2)
ket = qf.RY(pi / 2, 0).run(ket)
ket = qf.RX(pi, 0).run(ket)
ket = qf.RY(pi / 2, 1).run(ket)
ket = qf.RX(pi, 1).run(ket)
ket = qf.CNOT(0, 1).run(ket)
ket = qf.RX(-pi / 2, 1).run(ket)
ket = qf.RY(4.71572463191, 1).run(ket)
ket = qf.RX(pi / 2, 1).run(ket)
ket = qf.CNOT(0, 1).run(ket)
ket = qf.RX(-2 * 2.74973750579, 0).run(ket)
ket = qf.RX(-2 * 2.74973750579, 1).run(ket)
assert qf.states_close(ket, ket_true)
def test_elements():
circ = qf.Circuit()
circ1 = qf.Circuit()
circ2 = qf.Circuit()
circ1 += qf.RY(pi / 2, 0)
circ1 += qf.RX(pi, 0)
circ1 += qf.RY(pi / 2, 1)
circ1 += qf.RX(pi, 1)
circ1 += qf.CNOT(0, 1)
circ2 += qf.RX(-pi / 2, 1)
circ2 += qf.RY(4.71572463191, 1)
circ2 += qf.RX(pi / 2, 1)
circ2 += qf.CNOT(0, 1)
circ2 += qf.RX(-2 * 2.74973750579, 0)
circ2 += qf.RX(-2 * 2.74973750579, 1)
circ += circ1
circ.extend(circ2)
gates = list(circ.elements)
assert len(gates) == 11
assert circ.size() == 11
assert gates[4].name == 'CNOT'
def test_qaoa_circuit():
circ = qf.Circuit()
circ += qf.RY(pi/2, 0)
circ += qf.RX(pi, 0)
circ += qf.RY(pi/2, 1)
circ += qf.RX(pi, 1)
circ += qf.CNOT(0, 1)
circ += qf.RX(-pi/2, 1)
circ += qf.RY(4.71572463191, 1)
circ += qf.RX(pi/2, 1)
circ += qf.CNOT(0, 1)
circ += qf.RX(-2*2.74973750579, 0)
circ += qf.RX(-2*2.74973750579, 1)
ket = qf.zero_state(2)
ket = circ.run(ket)
prog = qf.forest.circuit_to_pyquil(circ)
qvm = qf.forest.QuantumFlowQVM()
wf = qvm.load(prog).run().wait().wavefunction()
state = qf.forest.wavefunction_to_state(wf)
assert qf.states_close(ket, state)
def test_gatepow():
gates = [
qf.I(),
qf.X(),
qf.Y(),
qf.Z(),
qf.H(),
qf.S(),
qf.T(),
qf.PHASE(0.1),
qf.RX(0.2),
qf.RY(0.3),
qf.RZ(0.4),
qf.CZ(),
qf.CNOT(),
qf.SWAP(),
qf.ISWAP(),
qf.CPHASE00(0.5),
qf.CPHASE01(0.6),
qf.CPHASE10(0.6),
qf.CPHASE(0.7),
qf.PSWAP(0.15),
qf.CCNOT(),
qf.CSWAP(),
qf.TX(2.7),
qf.TY(1.2),
qf.TZ(0.3),
qf.ZYZ(3.5, 0.9, 2.1),
qf.CANONICAL(0.1, 0.2, 7.4),
qf.XX(1.8),
qf.YY(0.9),
qf.ZZ(0.45),
qf.PISWAP(0.2),
qf.EXCH(0.1),
qf.TH(0.3)
]
for gate in gates:
assert qf.gates_close(gate.H, gate**-1)
for gate in gates:
sqrt_gate = gate**(1 / 2)
two_gate = sqrt_gate @ sqrt_gate
assert qf.gates_close(gate, two_gate)
for gate in gates:
gate0 = gate**0.3
gate1 = gate**0.7
gate2 = gate0 @ gate1
assert qf.gates_close(gate, gate2)
for K in range(1, 5):
gate = qf.random_gate(K) # FIXME: Throw error on K=0
sqrt_gate = gate**0.5
two_gate = sqrt_gate @ sqrt_gate
assert qf.gates_close(gate, two_gate)
for gate in gates:
rgate = qf.Gate((gate**0.5).tensor)
tgate = rgate @ rgate
assert qf.gates_close(gate, tgate)
