def test_addition_circuit():
# Two bit addition circuit
circ = qf.addition_circuit([0, 1], [2, 3], [4, 5])
for c0 in range(0, 2):
for a0 in range(0, 4):
for a1 in range(0, 4):
expected = a0 + a1 + c0
b0 = int_to_bitlist(a0, 2)
b1 = int_to_bitlist(a1, 2)
bc = [c0]
bits = tuple(b0 + b1 + bc + [0])
state = np.zeros(shape=[2] * 6)
state[bits] = 1
ket = qf.State(state)
ket = circ.run(ket)
bits = ket.measure()
res = bits[[5, 2, 3]]
res = bitlist_to_int(res)
print(c0, a0, a1, expected, res)
assert res == expected
# Three bit addition circuit
circ = qf.addition_circuit([0, 1, 2], [3, 4, 5], [6, 7])
for c0 in range(0, 2):
for a0 in range(0, 8):
for a1 in range(0, 8):
expected = a0 + a1 + c0
b0 = int_to_bitlist(a0, 3)
b1 = int_to_bitlist(a1, 3)
bc = [c0]
bits = tuple(b0 + b1 + bc + [0])
state = np.zeros(shape=[2] * 8)
state[bits] = 1
ket = qf.State(state)
ket = circ.run(ket)
bits = ket.measure()
res = bits[[7, 3, 4, 5]]
res = bitlist_to_int(res)
print(c0, a0, a1, expected, res)
assert res == expected
with pytest.raises(ValueError):
qf.addition_circuit([0, 1, 2], [3, 4, 5, 6], [7, 8])
with pytest.raises(ValueError):
qf.addition_circuit([0, 1, 2], [3, 4, 5], [6, 7, 8])
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 true_ket():
# Adapted from referenceQVM
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
])
return qf.State(wf_true.reshape((2, 2)))
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_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_qaoa():
ket_true = [
0.00167784 + 1.00210180e-05 * 1j, 0.5 - 4.99997185e-01 * 1j,
0.5 - 4.99997185e-01 * 1j, 0.00167784 + 1.00210180e-05 * 1j
]
rho_true = qf.State(ket_true).asdensity()
rho = qf.zero_state(2).asdensity()
rho = qf.RY(pi / 2, 0).aschannel().evolve(rho)
rho = qf.RX(pi, 0).aschannel().evolve(rho)
rho = qf.RY(pi / 2, 1).aschannel().evolve(rho)
rho = qf.RX(pi, 1).aschannel().evolve(rho)
rho = qf.CNOT(0, 1).aschannel().evolve(rho)
rho = qf.RX(-pi / 2, 1).aschannel().evolve(rho)
rho = qf.RY(4.71572463191, 1).aschannel().evolve(rho)
rho = qf.RX(pi / 2, 1).aschannel().evolve(rho)
rho = qf.CNOT(0, 1).aschannel().evolve(rho)
rho = qf.RX(-2 * 2.74973750579, 0).aschannel().evolve(rho)
rho = qf.RX(-2 * 2.74973750579, 1).aschannel().evolve(rho)
assert qf.densities_close(rho, rho_true)
def test_memory() -> None:
ket0 = qf.zero_state(1)
assert ket0.memory == {}
ro = ["ro[0]", "ro[1]"]
ket1 = ket0.store({ro[1]: 1})
assert ket0.memory == {}
assert ket1.memory == {ro[1]: 1}
ket2 = qf.H(0).run(ket1)
assert ket2.memory == ket1.memory
ket3 = ket2.store({ro[1]: 0, ro[0]: 0})
assert ket3.memory == {ro[0]: 0, ro[1]: 0}
N = 4
wf = np.zeros(shape=[2] * N)
wf[(0, ) * N] = 1
ket = qf.State(wf, list(range(N)), {"a": 2})
assert ket.memory == {"a": 2}
assert isinstance(ket.memory, FrozenDict)
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_error() -> None:
ket = qf.zero_state(4)
with pytest.raises(ValueError):
qf.State(ket.tensor, [0, 1, 2])
