def test_merge() -> None:
circ0 = qf.Circuit([
qf.XPow(0.4, 0),
qf.XPow(0.2, 0),
qf.YPow(0.1, 1),
qf.YPow(0.1, 1),
qf.ZPow(0.1, 1),
qf.ZPow(0.1, 1),
])
dagc = qf.DAGCircuit(circ0)
qf.merge_tx(dagc)
qf.merge_tz(dagc)
qf.merge_ty(dagc)
circ1 = qf.Circuit(dagc)
assert len(circ1) == 3
def test_gates_phase_close() -> None:
gate0 = qf.ZPow(0.5, q0=0)
gate1 = qf.Circuit(qf.translate_tz_to_rz(gate0)).asgate() # type: ignore
assert qf.gates_close(gate0, gate1)
assert not qf.gates_phase_close(gate0, gate1)
assert qf.gates_phase_close(gate0, gate0)
gate2 = qf.XPow(0.5, q0=0)
assert not qf.gates_phase_close(gate0, gate2)
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_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_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_specialize_1q() -> None:
q0 = 10
assert isinstance(qf.ZPow(0.0, q0).specialize(), qf.I)
assert isinstance(qf.ZPow(0.25, q0).specialize(), qf.T)
assert isinstance(qf.ZPow(0.5, q0).specialize(), qf.S)
assert isinstance(qf.ZPow(1.0, q0).specialize(), qf.Z)
assert isinstance(qf.ZPow(1.5, q0).specialize(), qf.S_H)
assert isinstance(qf.ZPow(1.75, q0).specialize(), qf.T_H)
assert isinstance(qf.ZPow(1.99999999999, q0).specialize(), qf.I)
special_values = (
0.0,
0.25,
0.5,
1.0,
1.5,
1.75,
2.0,
0.17365,
np.pi,
np.pi / 2,
np.pi / 4,
)
special1p1q = (
qf.Rx,
qf.Ry,
qf.Rz,
qf.XPow,
qf.YPow,
qf.ZPow,
qf.PhaseShift,
qf.HPow,
qf.W,
)
for gatetype in special1p1q:
for value in special_values:
gate0 = gatetype(value, "q0")
gate1 = gate0.specialize()
assert gate0.qubits == gate1.qubits
assert qf.gates_close(gate0, gate1)
assert isinstance(qf.PhasedXPow(0.1234, 0.0, 1).specialize(), qf.I)
assert isinstance(qf.PhasedXPow(0.0, 1.0, 1).specialize(), qf.X)
assert isinstance(
qf.PhasedXPow(0.0213, 1.0, 1).specialize(), qf.PhasedXPow)
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_circuit_to_quirk() -> None:
# 2-qubit gates
quirk = "https://algassert.com/quirk#circuit={%22cols%22:[[1,%22X%22,%22%E2%80%A2%22],[%22%E2%80%A2%22,1,%22Z%22],[1,%22%E2%80%A2%22,%22Y%22],[%22Swap%22,1,%22Swap%22]]}" # noqa: E501
circ = qf.Circuit([qf.CNot(2, 1), qf.CZ(0, 2), qf.CY(1, 2), qf.Swap(0, 2)])
print()
print(urllib.parse.unquote(quirk))
print(quirk_url(circuit_to_quirk(circ)))
assert urllib.parse.unquote(quirk) == quirk_url(circuit_to_quirk(circ))
# 3-qubit gates
quirk = "https://algassert.com/quirk#circuit={%22cols%22:[[%22%E2%80%A2%22,%22%E2%80%A2%22,%22X%22],[%22%E2%80%A2%22,%22%E2%80%A2%22,%22Z%22],[%22%E2%80%A2%22,%22Swap%22,%22Swap%22]]}" # noqa: E501
circ = qf.Circuit([qf.CCNot(0, 1, 2), qf.CCZ(0, 1, 2), qf.CSwap(0, 1, 2)])
print()
print(urllib.parse.unquote(quirk))
print(quirk_url(circuit_to_quirk(circ)))
assert urllib.parse.unquote(quirk) == quirk_url(circuit_to_quirk(circ))
test0 = "https://algassert.com/quirk#circuit={%22cols%22:[[%22Z%22,%22Y%22,%22X%22,%22H%22]]}" # noqa: E501
test0 = urllib.parse.unquote(test0)
circ = qf.Circuit([qf.Z(0), qf.Y(1), qf.X(2), qf.H(3)])
print(test0)
print(quirk_url(circuit_to_quirk(circ)))
assert test0 == quirk_url(circuit_to_quirk(circ))
test_halfturns = "https://algassert.com/quirk#circuit={%22cols%22:[[%22X^%C2%BD%22,%22Y^%C2%BD%22,%22Z^%C2%BD%22],[%22X^-%C2%BD%22,%22Y^-%C2%BD%22,%22Z^-%C2%BD%22]]}" # noqa: E501
test_halfturns = urllib.parse.unquote(test_halfturns)
circ = qf.Circuit(
[qf.V(0),
qf.SqrtY(1),
qf.S(2),
qf.V(0).H,
qf.SqrtY(1).H,
qf.S(2).H])
print(test_halfturns)
print(quirk_url(circuit_to_quirk(circ)))
assert test_halfturns == quirk_url(circuit_to_quirk(circ))
quarter_turns = "https://algassert.com/quirk#circuit={%22cols%22:[[%22Z^%C2%BC%22],[%22Z^-%C2%BC%22]]}" # noqa: E501
s = urllib.parse.unquote(quarter_turns)
circ = qf.Circuit([qf.T(0), qf.T(0).H])
assert s == quirk_url(circuit_to_quirk(circ))
# GHZ circuit
quirk = "https://algassert.com/quirk#circuit={%22cols%22:[[%22H%22],[%22%E2%80%A2%22,%22X%22],[1,%22%E2%80%A2%22,%22X%22]]}" # noqa: E501
circ = qf.Circuit([qf.H(0), qf.CNot(0, 1), qf.CNot(1, 2)])
print(urllib.parse.unquote(quirk))
print(quirk_url(circuit_to_quirk(circ)))
assert urllib.parse.unquote(quirk) == quirk_url(circuit_to_quirk(circ))
test_formulaic = "https://algassert.com/quirk#circuit={%22cols%22:[[{%22id%22:%22X^ft%22,%22arg%22:%220.1%22},{%22id%22:%22Y^ft%22,%22arg%22:%220.2%22},{%22id%22:%22Z^ft%22,%22arg%22:%220.3%22}],[{%22id%22:%22Rxft%22,%22arg%22:%220.4%22},{%22id%22:%22Ryft%22,%22arg%22:%220.5%22},{%22id%22:%22Rzft%22,%22arg%22:%220.6%22}]]}" # noqa: E501
s = urllib.parse.unquote(test_formulaic)
circ = qf.Circuit([
qf.XPow(0.1, 0),
qf.YPow(0.2, 1),
qf.ZPow(0.3, 2),
qf.Rx(0.4, 0),
qf.Ry(0.5, 1),
qf.Rz(0.6, 2),
])
assert s == quirk_url(circuit_to_quirk(circ))
def test_tz_specialize() -> None:
for t in [-0.25, 0, 0.25, 0.5, 1.0, 1.5, 1.75, 2.0]:
gate0 = qf.ZPow(t, 0)
gate1 = gate0.specialize()
assert qf.gates_close(gate0, gate1)
assert not isinstance(gate1, qf.ZPow)
def test_parametric_Z() -> None:
assert qf.gates_close(qf.ZPow(0.25, 1), qf.T(1))
assert qf.gates_close(qf.ZPow(0.5, 2), qf.S(2))
assert qf.gates_close(qf.ZPow(1.0, 3), qf.Z(3))