def test_fubini_study_angle() -> None:
for _ in range(REPS):
theta = random.uniform(-np.pi, +np.pi)
ang = qf.fubini_study_angle(qf.I(0).tensor, qf.Rx(theta, 0).su().tensor)
assert np.isclose(2 * ang / abs(theta), 1.0)
ang = qf.fubini_study_angle(qf.I(0).tensor, qf.Ry(theta, 0).tensor)
assert np.isclose(2 * ang / abs(theta), 1.0)
ang = qf.fubini_study_angle(qf.I(0).tensor, qf.Rz(theta, 0).tensor)
assert np.isclose(2 * ang / abs(theta), 1.0)
ang = qf.fubini_study_angle(qf.Swap(0, 1).tensor, qf.PSwap(theta, 0, 1).tensor)
assert np.isclose(2 * ang / abs(theta), 1.0)
ang = qf.fubini_study_angle(qf.I(0).tensor, qf.PhaseShift(theta, 0).tensor)
assert np.isclose(2 * ang / abs(theta), 1.0)
assert qf.fubini_study_close(qf.Rz(theta, 0).tensor, qf.Rz(theta, 0).tensor)
for n in range(1, 6):
eye = qf.IdentityGate(list(range(n)))
assert np.isclose(qf.fubini_study_angle(eye.tensor, eye.tensor), 0.0)
with pytest.raises(ValueError):
qf.fubini_study_angle(qf.RandomGate([1]).tensor, qf.RandomGate([0, 1]).tensor)
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_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_gates_close():
assert not qf.gates_close(qf.I(), qf.identity_gate(2))
assert qf.gates_close(qf.I(), qf.I())
assert qf.gates_close(qf.P0(), qf.P0())
assert not qf.gates_close(qf.P0(), qf.P1())
assert qf.gates_close(qf.CNOT(0, 1), qf.CNOT(0, 1))
assert not qf.gates_close(qf.CNOT(1, 0), qf.CNOT(0, 1))
def test_circuit_to_qutip() -> None:
q0, q1, q2 = 0, 1, 2
circ0 = qf.Circuit()
circ0 += qf.I(q0)
circ0 += qf.Ph(0.1, q0)
circ0 += qf.X(q0)
circ0 += qf.Y(q1)
circ0 += qf.Z(q0)
circ0 += qf.S(q1)
circ0 += qf.T(q2)
circ0 += qf.H(q0)
circ0 += qf.H(q1)
circ0 += qf.H(q2)
circ0 += qf.CNot(q0, q1)
circ0 += qf.CNot(q1, q0)
circ0 += qf.Swap(q0, q1)
circ0 += qf.ISwap(q0, q1)
circ0 += qf.CCNot(q0, q1, q2)
circ0 += qf.CSwap(q0, q1, q2)
circ0 == qf.I(q0)
circ0 += qf.Rx(0.1, q0)
circ0 += qf.Ry(0.2, q1)
circ0 += qf.Rz(0.3, q2)
circ0 += qf.V(q0)
circ0 += qf.H(q1)
circ0 += qf.CY(q0, q1)
circ0 += qf.CZ(q0, q1)
circ0 += qf.CS(q1, q2)
circ0 += qf.CT(q0, q1)
circ0 += qf.SqrtSwap(q0, q1)
circ0 += qf.SqrtISwap(q0, q1)
circ0 += qf.CCNot(q0, q1, q2)
circ0 += qf.CSwap(q0, q1, q2)
circ0 += qf.CPhase(0.1, q1, q2)
# Not yet supported
# circ0 += qf.B(q1, q2)
# circ0 += qf.Swap(q1, q2) ** 0.1
qbc = xqutip.circuit_to_qutip(circ0)
U = gate_sequence_product(qbc.propagators())
gate0 = qf.Unitary(U.full(), qubits=[0, 1, 2])
assert qf.gates_close(gate0, circ0.asgate())
circ1 = xqutip.qutip_to_circuit(qbc)
assert qf.gates_close(circ0.asgate(), circ1.asgate())
def test_diamond_norm() -> None:
# Test cases borrowed from qutip,
# https://github.com/qutip/qutip/blob/master/qutip/tests/test_metrics.py
# which were in turn generated using QuantumUtils for MATLAB
# (https://goo.gl/oWXhO9)
RTOL = 0.01
chan0 = qf.I(0).aschannel()
chan1 = qf.X(0).aschannel()
dn = diamond_norm(chan0, chan1)
assert np.isclose(2.0, dn, rtol=RTOL)
turns_dnorm = [
[1.000000e-03, 3.141591e-03],
[3.100000e-03, 9.738899e-03],
[1.000000e-02, 3.141463e-02],
[3.100000e-02, 9.735089e-02],
[1.000000e-01, 3.128689e-01],
[3.100000e-01, 9.358596e-01],
]
for turns, target in turns_dnorm:
chan0 = qf.XPow(0.0, 0).aschannel()
chan1 = qf.XPow(turns, 0).aschannel()
dn = diamond_norm(chan0, chan1)
assert np.isclose(target, dn, rtol=RTOL)
hadamard_mixtures = [
[1.000000e-03, 2.000000e-03],
[3.100000e-03, 6.200000e-03],
[1.000000e-02, 2.000000e-02],
[3.100000e-02, 6.200000e-02],
[1.000000e-01, 2.000000e-01],
[3.100000e-01, 6.200000e-01],
]
for p, target in hadamard_mixtures:
tensor = qf.I(0).aschannel().tensor * (
1 - p) + qf.H(0).aschannel().tensor * p
chan0 = qf.Channel(tensor, [0])
chan1 = qf.I(0).aschannel()
dn = diamond_norm(chan0, chan1)
assert np.isclose(dn, target, rtol=RTOL)
chan0 = qf.YPow(0.5, 0).aschannel()
chan1 = qf.I(0).aschannel()
dn = diamond_norm(chan0, chan1)
assert np.isclose(dn, np.sqrt(2), rtol=RTOL)
chan0 = qf.CNot(0, 1).aschannel()
chan1 = qf.CNot(1, 0).aschannel()
diamond_norm(chan0, chan1)
def test_diamond_norm():
# Test cases borrowed from qutip,
# https://github.com/qutip/qutip/blob/master/qutip/tests/test_metrics.py
# which were in turn generated using QuantumUtils for MATLAB
# (https://goo.gl/oWXhO9)
RTOL = 0.01
chan0 = qf.I(0).aschannel()
chan1 = qf.X(0).aschannel()
dn = qf.diamond_norm(chan0, chan1)
assert np.isclose(2.0, dn, rtol=RTOL)
turns_dnorm = [[1.000000e-03, 3.141591e-03],
[3.100000e-03, 9.738899e-03],
[1.000000e-02, 3.141463e-02],
[3.100000e-02, 9.735089e-02],
[1.000000e-01, 3.128689e-01],
[3.100000e-01, 9.358596e-01]]
for turns, target in turns_dnorm:
chan0 = qf.TX(0).aschannel()
chan1 = qf.TX(turns).aschannel()
dn = qf.diamond_norm(chan0, chan1)
assert np.isclose(target, dn, rtol=RTOL)
hadamard_mixtures = [[1.000000e-03, 2.000000e-03],
[3.100000e-03, 6.200000e-03],
[1.000000e-02, 2.000000e-02],
[3.100000e-02, 6.200000e-02],
[1.000000e-01, 2.000000e-01],
[3.100000e-01, 6.200000e-01]]
for p, target in hadamard_mixtures:
# FIXME: implement __rmul__ for channels
chan0 = qf.I(0).aschannel() * (1 - p) + qf.H(0).aschannel() * p
chan1 = qf.I(0).aschannel()
dn = qf.diamond_norm(chan0, chan1)
assert np.isclose(dn, target, rtol=RTOL)
chan0 = qf.TY(0.5, 0).aschannel()
chan1 = qf.I(0).aschannel()
dn = qf.diamond_norm(chan0, chan1)
assert np.isclose(dn, np.sqrt(2), rtol=RTOL)
chan0 = qf.CNOT(0, 1).aschannel()
chan1 = qf.CNOT(1, 0).aschannel()
qf.diamond_norm(chan0, chan1)
def test_bloch_decomposition():
theta = 1.23
gate0 = qf.RN(theta, 1, 0, 0)
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
gate0 = qf.RN(theta, 0, 1, 0)
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
gate0 = qf.RN(theta, 0, 0, 1)
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
gate0 = qf.RN(pi, np.sqrt(2), 0, np.sqrt(2))
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
for _ in range(REPS):
gate0 = qf.random_gate(qubits=[0])
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
gate0 = qf.I(0)
gate1 = qf.bloch_decomposition(gate0).elements[0]
assert qf.gates_close(gate0, gate1)
def test_decomp_stdgates():
gate0 = qf.I(0, 1)
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.CNOT(0, 1)
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.SWAP(0, 1)
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.ISWAP(0, 1)
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.CNOT(0, 1)**0.5
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.SWAP(0, 1)**0.5
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate0 = qf.ISWAP(0, 1)**0.5
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
def test_bloch_decomposition() -> None:
theta = 1.23
gate0 = qf.Rn(theta, 1, 0, 0, 9)
gate1 = qf.bloch_decomposition(gate0)[0]
assert isinstance(gate1, qf.Gate)
assert qf.gates_close(gate0, gate1)
gate0 = qf.Rn(theta, 0, 1, 0, 9)
gate1 = qf.bloch_decomposition(gate0)[0]
assert isinstance(gate1, qf.Gate)
assert qf.gates_close(gate0, gate1)
gate0 = qf.Rn(theta, 0, 0, 1, 9)
gate1 = qf.bloch_decomposition(gate0)[0]
assert isinstance(gate1, qf.Gate)
assert qf.gates_close(gate0, gate1)
gate0 = qf.Rn(pi, np.sqrt(2), 0, np.sqrt(2), 9)
gate1 = qf.bloch_decomposition(gate0)[0]
assert isinstance(gate1, qf.Gate)
assert qf.gates_close(gate0, gate1)
for _ in range(REPS):
gate3 = qf.RandomGate(qubits=[0])
gate4 = qf.bloch_decomposition(gate3)[0]
assert isinstance(gate4, qf.Gate)
assert qf.gates_close(gate3, gate4)
gate5 = qf.I(0)
gate6 = qf.bloch_decomposition(gate5)[0]
assert isinstance(gate6, qf.Gate)
assert qf.gates_close(gate5, gate6)
def test_PauliGate() -> None:
pauli0 = 0.5 * np.pi * qf.sX(0) * qf.sX(1)
alpha = 0.4
circ = qf.PauliGate(pauli0, alpha)
coords = qf.canonical_coords(circ.asgate())
assert np.isclose(coords[0], 0.4)
pauli1 = np.pi * qf.sX(0) * qf.sX(1) * qf.sY(2) * qf.sZ(3)
_ = qf.PauliGate(pauli1, alpha)
top2 = nx.star_graph(4)
pauli2 = 0.5 * np.pi * qf.sX(1) * qf.sY(2) * qf.sZ(3)
_ = qf.PauliGate(pauli2, alpha).decompose(top2)
alpha = 0.2
top3 = nx.star_graph(4)
pauli3 = 0.5 * np.pi * qf.sX(1) * qf.sX(2)
circ3 = qf.Circuit(qf.PauliGate(pauli3, alpha).decompose(top3))
assert qf.circuits_close(circ3, qf.Circuit([qf.I(0), qf.XX(alpha, 1, 2)]))
qf.PauliGate(qf.sI(0), alpha).decompose(top2)
with pytest.raises(ValueError):
pauli4 = 0.5j * np.pi * qf.sX(1) * qf.sX(2)
_ = qf.Circuit(qf.PauliGate(pauli4, alpha).decompose(top3))
top4 = nx.DiGraph()
nx.add_path(top4, [3, 2, 1, 0])
_ = qf.Circuit(qf.PauliGate(pauli3, alpha).decompose(top4))
def test_cphase_gates():
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
gate11 = qf.control_gate(0, qf.PHASE(theta, 1))
assert qf.gates_close(gate11, qf.CPHASE(theta, 0, 1))
gate01 = qf.conditional_gate(0, qf.PHASE(theta, 1), qf.I(1))
assert qf.gates_close(gate01, qf.CPHASE01(theta))
gate00 = qf.identity_gate(2)
gate00 = qf.X(0) @ gate00
gate00 = qf.X(1) @ gate00
gate00 = gate11 @ gate00
gate00 = qf.X(0) @ gate00
gate00 = qf.X(1) @ gate00
assert qf.gates_close(gate00, qf.CPHASE00(theta))
gate10 = qf.identity_gate(2)
gate10 = qf.X(0) @ gate10
gate10 = qf.X(1) @ gate10
gate10 = gate01 @ gate10
gate10 = qf.X(0) @ gate10
gate10 = qf.X(1) @ gate10
assert qf.gates_close(gate10, qf.CPHASE10(theta))
def test_parametric_TX_TY_TZ():
gate = qf.I()
gate = qf.TZ(1 / 2) @ gate
gate = qf.TX(1 / 2) @ gate
gate = qf.TZ(1 / 2) @ gate
assert qf.gates_close(gate, qf.H())
def test_cirq_simulator() -> None:
q0, q1, q2 = "q0", "q1", "q2"
circ0 = qf.Circuit()
circ0 += qf.I(q0)
circ0 += qf.I(q1)
circ0 += qf.I(q2)
circ0 += qf.X(q1)
circ0 += qf.Y(q2)
circ0 += qf.Z(q0)
circ0 += qf.S(q1)
circ0 += qf.T(q2)
circ0 += qf.H(q0)
circ0 += qf.H(q1)
circ0 += qf.H(q2)
circ0 += qf.XPow(0.6, q0)
circ0 += qf.YPow(0.6, q1)
circ0 += qf.ZPow(0.6, q2)
circ0 += qf.XX(0.2, q0, q1)
circ0 += qf.YY(0.3, q1, q2)
circ0 += qf.ZZ(0.4, q2, q0)
circ0 += qf.CZ(q0, q1)
circ0 += qf.CNot(q0, q1)
circ0 += qf.Swap(q0, q1)
circ0 += qf.ISwap(q0, q1)
circ0 += qf.CCZ(q0, q1, q2)
circ0 += qf.CCNot(q0, q1, q2)
circ0 += qf.CSwap(q0, q1, q2)
ket0 = qf.random_state([q0, q1, q2])
ket1 = circ0.run(ket0)
sim = CirqSimulator(circ0)
ket2 = sim.run(ket0)
assert ket1.qubits == ket2.qubits
print(qf.state_angle(ket1, ket2))
assert qf.states_close(ket1, ket2)
assert qf.states_close(circ0.run(), sim.run())
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_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_ZYZ():
t0 = random.uniform(-2, +2)
t1 = random.uniform(-2, +2)
t2 = random.uniform(-2, +2)
gate = qf.ZYZ(t0, t1, t2, 0)
assert qf.almost_unitary(gate)
inv = gate.H
assert type(gate) == type(inv)
assert qf.gates_close(qf.I(0), inv @ gate)
def test_inverse_tgates_1qubit():
gates = qf.TX, qf.TY, qf.TZ
for gate in gates:
for _ in range(REPS):
t = random.uniform(-2, +2)
g = gate(t)
inv = g.H
assert qf.gates_close(qf.I(), g @ inv)
assert type(g) == type(inv)
def test_inverse_parametric_1qubit():
gates = [qf.PHASE, qf.RX, qf.RY, qf.RZ]
for gate in gates:
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
g = gate(theta)
inv = g.H
assert qf.gates_close(qf.I(), g @ inv)
assert type(g) == type(inv)
def test_gate_inverse():
inv = qf.S().H
eye = qf.S() @ inv
assert qf.gates_close(eye, qf.I())
inv = qf.ISWAP().H
eye = qf.ISWAP() @ inv
assert qf.gates_close(eye, qf.identity_gate(2))
def test_outer_product():
with pytest.raises(ValueError):
ket = qf.zero_state(1)
gate = qf.I(2)
qf.outer_product(ket.vec, gate.vec)
with pytest.raises(ValueError):
ket0 = qf.zero_state([0, 1, 2])
ket1 = qf.zero_state([2, 3, 4])
qf.outer_product(ket0.vec, ket1.vec)
def _cli():
gates = [
qf.I(0),
qf.X(0),
qf.Y(0),
qf.Z(0),
qf.S(0),
qf.T(0),
qf.H(0),
qf.XPow(0.2, 0),
qf.YPow(0.2, 0),
qf.ZPow(0.2, 0),
qf.CNot(0, 1),
qf.CZ(0, 1),
qf.Swap(0, 1),
qf.ISwap(0, 1),
qf.CCNot(0, 1, 2),
qf.CCZ(0, 1, 2),
qf.CSwap(0, 1, 2),
]
print()
print("Gate QF GOPS Cirq GOPS")
# for n in range(4):
# circ = benchmark_circuit(QUBITS, GATES, qf.RandomGate([0,1]))
# t = timeit.timeit(lambda: circ.run(), number=REPS,
# timer=time.process_time)
# gops = int((GATES*REPS)/t)
# gops = int((gops * 100) + 0.5) / 100.0
# print(f"gate qubits: {n} gops:{gops}")
for gate in gates:
circ = benchmark_circuit(QUBITS, GATES, gate)
t = timeit.timeit(lambda: circ.run(),
number=REPS,
timer=time.process_time)
cq = qf.xcirq.CirqSimulator(circ)
t2 = timeit.timeit(lambda: cq.run(),
number=REPS,
timer=time.process_time)
gops = int((GATES * REPS) / t)
gops = int((gops * 100) + 0.5) / 100.0
gops2 = int((GATES * REPS) / t2)
gops2 = int((gops2 * 100) + 0.5) / 100.0
if gops / gops2 > 0.8:
print(gate.name, "\t", gops, "\t", gops2)
else:
print(gate.name, "\t", gops, "\t", gops2, "\t☹️")
def test_circuit_to_circ() -> None:
q0, q1, q2 = "q0", "q1", "q2"
circ0 = qf.Circuit()
circ0 += qf.I(q0)
circ0 += qf.X(q1)
circ0 += qf.Y(q2)
circ0 += qf.Z(q0)
circ0 += qf.S(q1)
circ0 += qf.T(q2)
circ0 += qf.H(q0)
circ0 += qf.H(q1)
circ0 += qf.H(q2)
circ0 += qf.XPow(0.6, q0)
circ0 += qf.YPow(0.6, q1)
circ0 += qf.ZPow(0.6, q2)
circ0 += qf.XX(0.2, q0, q1)
circ0 += qf.YY(0.3, q1, q2)
circ0 += qf.ZZ(0.4, q2, q0)
circ0 += qf.CZ(q0, q1)
circ0 += qf.CNot(q0, q1)
circ0 += qf.Swap(q0, q1)
circ0 += qf.ISwap(q0, q1)
circ0 += qf.CCZ(q0, q1, q2)
circ0 += qf.CCNot(q0, q1, q2)
circ0 += qf.CSwap(q0, q1, q2)
circ0 += qf.FSim(1, 2, q0, q1)
diag0 = qf.circuit_to_diagram(circ0)
# print()
# print(diag0)
cqc = circuit_to_cirq(circ0)
# print(cqc)
circ1 = cirq_to_circuit(cqc)
diag1 = qf.circuit_to_diagram(circ1)
# print()
# print(diag1)
assert diag0 == diag1
def test_qsim_simulator() -> None:
q0, q1, q2 = "q0", "q1", "q2"
circ0 = qf.Circuit()
circ0 += qf.I(q0)
circ0 += qf.H(q0)
circ0 += qf.Z(q1)
circ0 += qf.Z(q2)
circ0 += qf.Z(q1)
circ0 += qf.S(q1)
circ0 += qf.T(q2)
circ0 += qf.H(q0)
circ0 += qf.H(q2)
# Waiting for bugfix in qsim
circ0 += qf.Z(q1)**0.2
circ0 += qf.X(q1)**0.2
circ0 += qf.XPow(0.2, q0)
circ0 += qf.YPow(0.2, q1)
circ0 += qf.ZPow(0.5, q2)
circ0 += qf.CZ(q0, q1)
circ0 += qf.CNot(q0, q1)
# circ0 += qf.SWAP(q0, q1) # No SWAP!
# circ0 += qf.ISWAP(q0, q1) # Waiting for bugfix in qsim
circ0 += qf.FSim(0.1, 0.2, q0, q1)
# No 3-qubit gates
# Initial state not yet supported in qsim
# ket0 = qf.random_state([q0, q1, q2])
ket1 = circ0.run()
sim = QSimSimulator(circ0)
ket2 = sim.run()
assert ket1.qubits == ket2.qubits
print("QF", ket1)
print("QS", ket2)
assert qf.states_close(ket1, ket2)
assert qf.states_close(circ0.run(), sim.run())
def test_partial_trace():
data = [1] * (2**16)
r8 = qf.QubitVector(data, range(2))
r4 = qf.QubitVector(data, range(4))
r2 = qf.QubitVector(data, range(8))
tr2 = r2.partial_trace([1])
assert tr2.qubits == (0, 2, 3, 4, 5, 6, 7)
assert tr2.rank == 2
tr2 = r2.partial_trace([2, 3])
assert tr2.qubits == (0, 1, 4, 5, 6, 7)
assert tr2.rank == 2
tr4 = r4.partial_trace([0])
assert tr4.qubits == (1, 2, 3)
assert tr4.rank == 4
tr8 = r8.partial_trace([1])
assert tr8.qubits == (0, )
assert tr8.rank == 8
with pytest.raises(ValueError):
r2.partial_trace(range(8))
chan012 = qf.identity_gate(3).aschannel()
assert np.isclose(qf.asarray(chan012.trace()), 64) # 2**(2**3)
chan02 = chan012.partial_trace([1])
assert np.isclose(qf.asarray(chan02.trace()), 32) # TODO: Checkme
chan2 = chan012.partial_trace([0, 1])
assert np.isclose(qf.asarray(chan2.trace()), 16) # TODO: checkme
# partial traced channels should be identities still, upto normalization
assert qf.channels_close(chan2, qf.I(2).aschannel())
# TODO: Channel.normalize()
with pytest.raises(ValueError):
qf.zero_state(4).vec.partial_trace([1, 2])
def test_I():
assert np.allclose(qf.I().vec.asarray(), np.eye(2))
assert np.allclose(qf.I(0, 1).vec.asarray().reshape((4, 4)), np.eye(4))
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)
def test_parametric_Y():
pseudo_hadamard = qf.TY(1.5)
inv_pseudo_hadamard = qf.TY(0.5)
gate = pseudo_hadamard @ inv_pseudo_hadamard
assert qf.gates_close(gate, qf.I())
def test_channel_trace():
chan = qf.I(0).aschannel()
assert np.isclose(qf.asarray(chan.trace()), 4)
def test_visualize_circuit() -> None:
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, 4)
circ += qf.Rz((1 / 3) * pi, 5)
circ += qf.Ry(0.222, 6)
circ += qf.XPow(0.5, 0)
circ += qf.YPow(0.5, 2)
circ += qf.ZPow(0.4, 2)
circ += qf.HPow(0.5, 3)
circ += qf.ZPow(0.47276, 1)
# Gate with symbolic parameter
# gate = qf.Rz(Symbol('\\theta'), 1)
# circ += gate
circ += qf.CNot(1, 2)
circ += qf.CNot(2, 1)
# circ += qf.IDEN(*range(8))
circ += qf.ISwap(4, 2)
circ += qf.ISwap(6, 5)
circ += qf.CZ(1, 3)
circ += qf.Swap(1, 5)
# circ += qf.Barrier(0, 1, 2, 3, 4, 5, 6) # Not yet supported in latex
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.XX(0.25, 1, 4)
circ += qf.XX(0.25, 1, 2)
circ += qf.YY(0.75, 1, 3)
circ += qf.ZZ(1 / 3, 3, 1)
circ += qf.CPhase(0, 0, 1)
circ += qf.CPhase(pi * 1 / 2, 0, 4)
circ += qf.Can(1 / 3, 1 / 2, 1 / 2, 0, 1)
circ += qf.Can(1 / 3, 1 / 2, 1 / 2, 2, 4)
circ += qf.Can(1 / 3, 1 / 2, 1 / 2, 6, 5)
# circ += qf.Measure(0)
# circ += qf.Measure(1, 1)
circ += qf.PSwap(pi / 2, 6, 7)
circ += qf.Ph(1 / 4, 7)
circ += qf.CH(1, 6)
circ += qf.visualization.NoWire([0, 1, 2])
# circ += qf.visualization.NoWire(4, 1, 2)
if os.environ.get("QF_VIZTEST"):
print()
print(qf.circuit_to_diagram(circ))
qf.circuit_to_diagram(circ)
qf.circuit_to_latex(circ)
qf.circuit_to_latex(circ, package="qcircuit")
qf.circuit_to_latex(circ, package="quantikz")
qf.circuit_to_diagram(circ)
qf.circuit_to_diagram(circ, use_unicode=False)
latex = qf.circuit_to_latex(circ, package="qcircuit")
print(latex)
if os.environ.get("QF_VIZTEST"):
qf.latex_to_image(latex).show()
latex = qf.circuit_to_latex(circ, package="quantikz")
print(latex)
if os.environ.get("QF_VIZTEST"):
qf.latex_to_image(latex).show()
