def test_decomp_stdgates() -> None:
gate0 = qf.IdentityGate([0, 1])
gate1 = qf.canonical_decomposition(gate0).asgate()
assert qf.gates_close(gate0, gate1)
gate2 = qf.CNot(0, 1)
gate3 = qf.canonical_decomposition(gate2).asgate()
assert qf.gates_close(gate2, gate3)
gate4 = qf.Swap(0, 1)
gate5 = qf.canonical_decomposition(gate4).asgate()
assert qf.gates_close(gate4, gate5)
gate6 = qf.ISwap(0, 1)
gate7 = qf.canonical_decomposition(gate6).asgate()
assert qf.gates_close(gate6, gate7)
gate8 = qf.CNot(0, 1)**0.5
gate9 = qf.canonical_decomposition(gate8).asgate()
assert qf.gates_close(gate8, gate9)
gate10 = qf.Swap(0, 1)**0.5
gate11 = qf.canonical_decomposition(gate10).asgate()
assert qf.gates_close(gate10, gate11)
gate12 = qf.ISwap(0, 1)**0.5
gate13 = qf.canonical_decomposition(gate12).asgate()
assert qf.gates_close(gate12, gate13)
def test_gate_H() -> None:
gate0 = qf.X(0)
assert gate0.cv_hermitian
assert gate0.H is gate0
gate1 = qf.ISwap(0, 1)
assert not gate1.cv_hermitian
assert qf.gates_close(gate1.H.H, gate1)
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 _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_gate2_to_diagrams() -> None:
circ = qf.Circuit()
circ += qf.CNot(0, 1)
circ += qf.CZ(0, 1)
circ += qf.CV(0, 1)
circ += qf.CV_H(0, 1)
circ += qf.CH(0, 1)
circ += qf.Swap(0, 1)
circ += qf.ISwap(0, 1)
circ += qf.CNot(0, 2)
circ += qf.CZ(0, 2)
circ += qf.CV(0, 2)
circ += qf.CV_H(0, 2)
circ += qf.CH(0, 2)
circ += qf.Swap(0, 2)
circ += qf.ISwap(0, 2)
circ += qf.CNot(2, 1)
circ += qf.CZ(2, 1)
circ += qf.CV(2, 1)
circ += qf.CV_H(2, 1)
circ += qf.CH(2, 1)
circ += qf.Swap(2, 1)
circ += qf.ISwap(2, 1)
print()
diag = qf.circuit_to_diagram(circ)
print(diag)
diag = qf.circuit_to_diagram(circ, use_unicode=False)
print(diag)
latex = qf.circuit_to_latex(circ)
if os.environ.get("QF_VIZTEST"):
qf.latex_to_image(latex).show()
def prepare_w4():
"""
Prepare a 4-qubit W state using sqrt(iswaps) and local gates
"""
circ = qf.Circuit()
circ += qf.X(1)
circ += qf.ISwap(1, 2)**0.5
circ += qf.S(2)
circ += qf.Z(2)
circ += qf.ISwap(2, 3)**0.5
circ += qf.S(3)
circ += qf.Z(3)
circ += qf.ISwap(0, 1)**0.5
circ += qf.S(0)
circ += qf.Z(0)
ket = circ.run()
return ket
def test_gate_permute() -> None:
gate0 = qf.CNot(0, 1)
gate1 = qf.CNot(1, 0)
assert not qf.gates_close(gate0, gate1)
gate2 = gate1.permute([0, 1])
assert gate2.qubits == (0, 1)
assert qf.gates_close(gate1, gate2)
gate3 = qf.ISwap(0, 1)
gate4 = gate3.permute([1, 0])
assert qf.gates_close(gate3, gate4)
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_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_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()
def test_xy() -> None:
assert qf.gates_close(qf.XY(0, 0, 1), qf.IdentityGate([0, 1]))
assert qf.gates_close(qf.XY(-0.5, 0, 1), qf.ISwap(0, 1))
assert qf.gates_close(qf.XY(0.5, 0, 1), qf.ISwap(0, 1).H)
def test_XY() -> None:
gate = qf.XY(-0.1, 0, 1)
assert qf.gates_close(gate, qf.ISwap(0, 1)**0.2)
def w16_circuit() -> qf.Circuit:
"""
Return a circuit that prepares the the 16-qubit W state using\
sqrt(iswaps) and local gates, respecting linear topology
"""
gates = [
qf.X(7),
qf.ISwap(7, 8)**0.5,
qf.S(8),
qf.Z(8),
qf.Swap(7, 6),
qf.Swap(6, 5),
qf.Swap(5, 4),
qf.Swap(8, 9),
qf.Swap(9, 10),
qf.Swap(10, 11),
qf.ISwap(4, 3)**0.5,
qf.S(3),
qf.Z(3),
qf.ISwap(11, 12)**0.5,
qf.S(12),
qf.Z(12),
qf.Swap(3, 2),
qf.Swap(4, 5),
qf.Swap(11, 10),
qf.Swap(12, 13),
qf.ISwap(2, 1)**0.5,
qf.S(1),
qf.Z(1),
qf.ISwap(5, 6)**0.5,
qf.S(6),
qf.Z(6),
qf.ISwap(10, 9)**0.5,
qf.S(9),
qf.Z(9),
qf.ISwap(13, 14)**0.5,
qf.S(14),
qf.Z(14),
qf.ISwap(1, 0)**0.5,
qf.S(0),
qf.Z(0),
qf.ISwap(2, 3)**0.5,
qf.S(3),
qf.Z(3),
qf.ISwap(5, 4)**0.5,
qf.S(4),
qf.Z(4),
qf.ISwap(6, 7)**0.5,
qf.S(7),
qf.Z(7),
qf.ISwap(9, 8)**0.5,
qf.S(8),
qf.Z(8),
qf.ISwap(10, 11)**0.5,
qf.S(11),
qf.Z(11),
qf.ISwap(13, 12)**0.5,
qf.S(12),
qf.Z(12),
qf.ISwap(14, 15)**0.5,
qf.S(15),
qf.Z(15),
]
circ = qf.Circuit(gates)
return circ
def test_pswap() -> None:
assert qf.gates_close(qf.Swap(2, 4), qf.PSwap(0, 2, 4))
assert qf.gates_close(qf.ISwap(3, 2), qf.PSwap(np.pi / 2, 3, 2))