def test_inverse():
# Random circuit
circ = qf.Circuit()
circ += qf.TY(1 / 2, 0)
circ += qf.H(0)
circ += qf.TY(1 / 2, 1)
circ += qf.TX(1.23123, 1)
circ += qf.CNOT(0, 1)
circ += qf.TX(-1 / 2, 1)
circ += qf.TY(4.71572463191 / pi, 1)
circ += qf.CNOT(0, 1)
circ += qf.TX(-2 * 2.74973750579 / pi, 0)
circ += qf.TX(-2 * 2.74973750579 / 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.extend(circ_inv)
ket = circ.run(ket)
assert qf.states_close(ket, qf.zero_state(2))
def test_CH():
# Construct a controlled Hadamard gate
gate = qf.identity_gate(2)
gate = qf.S(1).H @ gate
gate = qf.H(1) @ gate
gate = qf.T(1).H @ gate
gate = qf.CNOT(0, 1) @ gate
gate = qf.T(1) @ gate
gate = qf.H(1) @ gate
gate = qf.S(1) @ gate
# Do nothing
ket = qf.zero_state(2)
ket = gate.run(ket)
assert qf.states_close(ket, qf.zero_state(2))
# Do nothing
ket = qf.zero_state(2)
ket = qf.X(0).run(ket)
ket = gate.run(ket)
ket = qf.H(1).run(ket)
ket = qf.X(0).run(ket)
assert qf.states_close(ket, qf.zero_state(2))
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_state_angle() -> None:
ket0 = qf.random_state(1)
ket1 = qf.random_state(1)
qf.state_angle(ket0, ket1)
assert not qf.states_close(ket0, ket1)
assert qf.states_close(ket0, ket0)
def test_states_close():
ket0 = qf.w_state(4)
ket1 = qf.w_state(3)
ket2 = qf.w_state(4)
assert qf.states_close(ket0, ket2)
assert not qf.states_close(ket0, ket1)
assert qf.states_close(ket2, ket2)
def test_states_close() -> None:
ket0 = qf.w_state(4)
ket1 = qf.w_state(3)
ket2 = qf.w_state(4)
ket3 = qf.ghz_state(3)
assert qf.states_close(ket0, ket2)
assert not qf.states_close(ket1, ket3)
assert qf.states_close(ket2, ket2)
def test_qftgate() -> None:
circ = qf.Circuit()
circ += qf.X(2)
circ += qf.QFTGate([0, 1, 2])
ket = qf.zero_state(3)
ket = circ.run(ket)
true_qft = qf.State(
[
0.35355339 + 0.0j,
0.25000000 + 0.25j,
0.00000000 + 0.35355339j,
-0.25000000 + 0.25j,
-0.35355339 + 0.0j,
-0.25000000 - 0.25j,
0.00000000 - 0.35355339j,
0.25000000 - 0.25j,
]
)
assert qf.states_close(ket, true_qft)
assert isinstance(qf.QFTGate([0, 1, 2]).H, qf.InvQFTGate)
assert isinstance(qf.QFTGate([0, 1, 2]).H.H, qf.QFTGate)
qf.QFTGate([0, 1, 2]).H.tensor
def test_belltest():
prog = qf.Program()
prog += qf.Call('H', [], [0])
prog += qf.Call('CNOT', [], [0, 1])
ket = prog.run()
assert qf.states_close(ket, qf.ghz_state(2))
def test_join_gates():
gate = qf.join_gates(qf.H(0), qf.X(1))
ket = qf.zero_state(2)
ket = gate.run(ket)
ket = qf.H(0).run(ket)
ket = qf.X(1).run(ket)
assert qf.states_close(ket, qf.zero_state(2))
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_ccnot_circuit():
ket0 = qf.random_state(3)
ket1 = qf.CCNOT(0, 1, 2).run(ket0)
ket2 = qf.ccnot_circuit([0, 1, 2]).run(ket0)
assert qf.states_close(ket1, ket2)
with pytest.raises(ValueError):
qf.ccnot_circuit([0, 1, 2, 3])
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_inverse() -> None:
dag = qf.DAGCircuit(_test_circ())
inv_dag = dag.H
ket0 = qf.random_state(2)
ket1 = dag.run(ket0)
ket2 = inv_dag.run(ket1)
assert qf.states_close(ket0, ket2)
def test_gate_run(gatet: Type[qf.StdGate]) -> None:
gate0 = _randomize_gate(gatet)
gate1 = qf.Unitary(gate0.tensor, gate0.qubits)
ket = qf.random_state(gate0.qubits)
ket0 = gate0.run(ket)
ket1 = gate1.run(ket)
assert qf.states_close(ket0, ket1)
def test_initialize() -> None:
circ = qf.Circuit()
circ += qf.H(1)
ket = qf.random_state([0, 1, 2])
circ += qf.Initialize(ket)
assert circ.qubits == (0, 1, 2)
assert qf.states_close(circ.run(), ket)
assert qf.densities_close(circ.evolve(), ket.asdensity())
def test_defgate_param():
prog = qf.parse_quil(CP)
# ket0 = prog.compile()
# qf.print_state(ket0)
ket1 = prog.run()
qf.print_state(ket1)
ket = qf.zero_state(2)
ket = qf.X(0).run(ket)
ket = qf.X(1).run(ket)
ket = qf.CPHASE(1.0, 0, 1).run(ket)
qf.print_state(ket)
assert qf.states_close(ket1, ket)
def test_qft():
circ = qf.Circuit()
circ += qf.X(2)
circ.extend(qf.qft_circuit([0, 1, 2]))
ket = qf.zero_state(3)
ket = circ.run(ket)
true_qft = qf.State([
0.35355339 + 0.j, 0.25000000 + 0.25j, 0.00000000 + 0.35355339j,
-0.25000000 + 0.25j, -0.35355339 + 0.j, -0.25000000 - 0.25j,
0.00000000 - 0.35355339j, 0.25000000 - 0.25j
])
assert qf.states_close(ket, true_qft)
def test_identitygate() -> None:
qubits = [3, 4, 5, 6, 7, 8]
gate = qf.IdentityGate(qubits)
ket0 = qf.random_state(qubits)
ket1 = gate.run(ket0)
assert qf.states_close(ket0, ket1)
circ = qf.Circuit(gate.decompose())
assert len(circ) == 6
for n in range(1, 6):
assert qf.IdentityGate(list(range(n))).qubit_nb == n
assert gate.hamiltonian.is_zero()
assert gate ** 2 is gate
def test_qsim_translate() -> None:
q0, q1, q2 = "q0", "q1", "q2"
circ0 = qf.Circuit()
circ0 += qf.H(q0)
circ0 += qf.X(q1)
circ0 += qf.S_H(q0)
circ0 += qf.XX(0.2, q0, q1)
circ0 += qf.Can(0.2, 0.1, 0.4, q0, q2)
circ0 += qf.Swap(q0, q1)
ket1 = circ0.run()
sim = QSimSimulator(circ0, translate=True)
# print(sim._circuit)
ket2 = sim.run()
assert qf.states_close(ket1, ket2)
def test_qaoa_circuit() -> None:
circ = qf.Circuit()
circ += qf.Ry(np.pi / 2, 0)
circ += qf.Rx(np.pi, 0)
circ += qf.Ry(np.pi / 2, 1)
circ += qf.Rx(np.pi, 1)
circ += qf.CNot(0, 1)
circ += qf.Rx(-np.pi / 2, 1)
circ += qf.Ry(4.71572463191, 1)
circ += qf.Rx(np.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_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_qaoa_circuit_turns():
circ = qf.Circuit()
circ += qf.TY(1 / 2, 0)
circ += qf.TX(1, 0)
circ += qf.TY(1 / 2, 1)
circ += qf.TX(1, 1)
circ += qf.CNOT(0, 1)
circ += qf.TX(-1 / 2, 1)
circ += qf.TY(4.71572463191 / pi, 1)
circ += qf.TX(1 / 2, 1)
circ += qf.CNOT(0, 1)
circ += qf.TX(-2 * 2.74973750579 / pi, 0)
circ += qf.TX(-2 * 2.74973750579 / pi, 1)
ket = qf.zero_state(2)
ket = circ.run(ket)
assert qf.states_close(ket, true_ket())
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_circuit():
wf_true = [0.00167784 + 1.00210180e-05*1j, 0.50000000 - 4.99997185e-01*1j,
0.50000000 - 4.99997185e-01*1j, 0.00167784 + 1.00210180e-05*1j]
prog = qf.Program()
prog += qf.Call('RY', [np.pi/2], [0])
prog += qf.Call('RX', [np.pi], [0])
prog += qf.Call('RY', [np.pi/2], [1])
prog += qf.Call('RX', [np.pi], [1])
prog += qf.Call('CNOT', [], [0, 1])
prog += qf.Call('RX', [-np.pi/2], [1])
prog += qf.Call('RY', [4.71572463191], [1])
prog += qf.Call('RX', [np.pi/2], [1])
prog += qf.Call('CNOT', [], [0, 1])
prog += qf.Call('RX', [-2*2.74973750579], [0])
prog += qf.Call('RX', [-2*2.74973750579], [1])
test_state = prog.run()
true_state = qf.State(wf_true)
assert qf.states_close(test_state, true_state)
def test_reset() -> None:
reset = qf.Reset(0, 1, 2)
ket = qf.random_state([0, 1, 2, 3])
ket = reset.run(ket)
assert ket.tensor[1, 1, 0, 0] == 0.0
assert str(reset) == "Reset 0 1 2"
reset = qf.Reset()
ket = qf.random_state([0, 1, 2, 3])
ket = reset.run(ket)
assert qf.states_close(ket, qf.zero_state([0, 1, 2, 3]))
assert str(reset) == "Reset"
with pytest.raises(TypeError):
reset.evolve(qf.random_density([0, 1, 3]))
with pytest.raises(TypeError):
reset.asgate()
with pytest.raises(TypeError):
reset.aschannel()
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_qaoa_circuit() -> None:
# Kudos: 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(np.pi / 2, 0).run(ket)
ket = qf.Rx(np.pi, 0).run(ket)
ket = qf.Ry(np.pi / 2, 1).run(ket)
ket = qf.Rx(np.pi, 1).run(ket)
ket = qf.CNot(0, 1).run(ket)
ket = qf.Rx(-np.pi / 2, 1).run(ket)
ket = qf.Ry(4.71572463191, 1).run(ket)
ket = qf.Rx(np.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_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_defgate():
prog = qf.parse_quil(HADAMARD)
ket = prog.run()
qf.print_state(ket)
assert qf.states_close(ket, qf.ghz_state(1))
def test_control_circuit():
ccnot = qf.control_circuit([0, 1], qf.X(2))
ket0 = qf.random_state(3)
ket1 = qf.CCNOT(0, 1, 2).run(ket0)
ket2 = ccnot.run(ket0)
assert qf.states_close(ket1, ket2)