def test_CH() -> None:
gate1 = qf.CH(0, 1)
# I picked up this circuit for a CH gate from qiskit
# qiskit/extensions/standard/ch.py
# But it clearly far too long. CH is locally equivalent to CNOT,
# so requires only one CNOT gate.
circ2 = qf.Circuit([
qf.H(1),
qf.S_H(1),
qf.CNot(0, 1),
qf.H(1),
qf.T(1),
qf.CNot(0, 1),
qf.T(1),
qf.H(1),
qf.S(1),
qf.X(1),
qf.S(0),
])
assert qf.gates_close(gate1, circ2.asgate())
# Here's a better decomposition
circ1 = qf.Circuit([qf.YPow(+0.25, 1), qf.CNot(0, 1), qf.YPow(-0.25, 1)])
assert qf.gates_close(gate1, circ1.asgate())
assert qf.circuits_close(circ1, circ2)
def test_inverse() -> None:
# Random circuit
circ = qf.Circuit()
circ += qf.YPow(1 / 2, 0)
circ += qf.H(0)
circ += qf.YPow(1 / 2, 1)
circ += qf.XPow(1.23123, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-1 / 2, 1)
circ += qf.YPow(4.71572463191 / np.pi, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 0)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 1)
circ_inv = circ.H
ket = circ.run()
# qf.print_state(ket)
ket = circ_inv.run(ket)
# qf.print_state(ket)
# print(ket.qubits)
# print(true_ket().qubits)
assert qf.states_close(ket, qf.zero_state(2))
ket = qf.zero_state(2)
circ += circ_inv
ket = circ.run(ket)
assert qf.states_close(ket, qf.zero_state(2))
def test_circuit_wires() -> None:
circ = qf.Circuit()
circ += qf.YPow(1 / 2, 0)
circ += qf.XPow(1, 10)
circ += qf.YPow(1 / 2, 1)
circ += qf.XPow(1, 1)
circ += qf.CNot(0, 4)
bits = circ.qubits
assert bits == (0, 1, 4, 10)
def test_implicit_state() -> None:
circ = qf.Circuit()
circ += qf.YPow(1 / 2, 0)
circ += qf.H(0)
circ += qf.YPow(1 / 2, 1)
ket = circ.run() # Implicit state
assert len(ket.qubits) == 2
with pytest.raises(TypeError):
# Should fail because qubits aren't sortable, so no standard ordering
circ += qf.YPow(1 / 2, "namedqubit")
circ.qubits
def _test_circ() -> qf.Circuit:
# Adapted from referenceQVM
circ = qf.Circuit()
circ += qf.YPow(1 / 2, 0)
circ += qf.XPow(1, 0)
circ += qf.YPow(1 / 2, 1)
circ += qf.XPow(1, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-1 / 2, 1)
circ += qf.YPow(4.71572463191 / np.pi, 1)
circ += qf.XPow(1 / 2, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 0)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 1)
return circ
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_qaoa_circuit_turns() -> None:
circ = qf.Circuit()
circ += qf.YPow(1 / 2, 0)
circ += qf.XPow(1, 0)
circ += qf.YPow(1 / 2, 1)
circ += qf.XPow(1, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-1 / 2, 1)
circ += qf.YPow(4.71572463191 / np.pi, 1)
circ += qf.XPow(1 / 2, 1)
circ += qf.CNot(0, 1)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 0)
circ += qf.XPow(-2 * 2.74973750579 / np.pi, 1)
ket = qf.zero_state(2)
ket = circ.run(ket)
assert qf.states_close(ket, true_ket())
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 _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_canonical_decomp_sandwich() -> None:
for _ in range(REPS):
# Random CZ sandwich
circ0 = qf.Circuit()
circ0 += qf.RandomGate([0])
circ0 += qf.RandomGate([1])
circ0 += qf.CZ(0, 1)
circ0 += qf.YPow(0.4, 0)
circ0 += qf.YPow(0.25, 1)
circ0 += qf.CZ(0, 1)
circ0 += qf.RandomGate([0])
circ0 += qf.RandomGate([1])
gate0 = circ0.asgate()
circ1 = qf.canonical_decomposition(gate0)
gate1 = circ1.asgate()
assert qf.gates_close(gate0, gate1)
assert qf.almost_unitary(gate0)
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_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))