def test_fidelity():
rho0 = qf.random_density(4)
rho1 = qf.random_density(4)
fid = qf.fidelity(rho0, rho1)
print('FID', fid)
assert 0.0 <= fid <= 1.0
rho2 = qf.random_density([3, 2, 1, 0])
fid = qf.fidelity(rho0, rho2)
assert 0.0 <= fid <= 1.0
fid = qf.fidelity(rho0, rho0)
print('FID', fid)
assert fid == ALMOST_ONE
ket0 = qf.random_state(3)
ket1 = qf.random_state(3)
fid0 = qf.state_fidelity(ket0, ket1)
rho0 = ket0.asdensity()
rho1 = ket1.asdensity()
fid1 = qf.fidelity(rho0, rho1)
assert qf.asarray(fid1 - fid0) == ALMOST_ZERO
fid2 = bk.cos(qf.fubini_study_angle(ket0.vec, ket1.vec))**2
assert qf.asarray(fid2 - fid0) == ALMOST_ZERO
def test_inner_product():
# also tested via test_gate_angle
for _ in range(REPS):
theta = random.uniform(-4 * pi, +4 * pi)
hs = qf.asarray(qf.inner_product(qf.RX(theta).vec, qf.RX(theta).vec))
print('RX({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(qf.inner_product(qf.RZ(theta).vec, qf.RZ(theta).vec))
print('RZ({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(qf.inner_product(qf.RY(theta).vec, qf.RY(theta).vec))
print('RY({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 2 == ALMOST_ONE
hs = qf.asarray(
qf.inner_product(qf.PSWAP(theta).vec,
qf.PSWAP(theta).vec))
print('PSWAP({}), hilbert_schmidt = {}'.format(theta, hs))
assert hs / 4 == ALMOST_ONE
with pytest.raises(ValueError):
qf.inner_product(qf.zero_state(0).vec, qf.X(0).vec)
with pytest.raises(ValueError):
qf.inner_product(qf.CNOT(0, 1).vec, qf.X(0).vec)
def test_normalize():
ket = qf.random_state(2)
assert qf.asarray(ket.norm()) == ALMOST_ONE
ket = qf.P0(0).run(ket)
assert qf.asarray(ket.norm()) != ALMOST_ONE
ket = ket.normalize()
assert qf.asarray(ket.norm()) == ALMOST_ONE
def test_density_trace():
rho = qf.random_density(3)
assert qf.asarray(rho.trace()) == ALMOST_ONE
rho = qf.Density(np.eye(8))
assert np.isclose(qf.asarray(rho.trace()), 8)
rho = rho.normalize()
assert np.isclose(qf.asarray(rho.trace()), 1)
def test_purity():
density = qf.ghz_state(4).asdensity()
assert qf.asarray(qf.purity(density)) == ALMOST_ONE
for _ in range(10):
rho = qf.random_density(4)
purity = np.real(qf.asarray(qf.purity(rho)))
assert purity < 1.0
assert purity >= 0.0
def test_projectors():
ket = qf.zero_state(1)
assert qf.asarray(qf.P0(0).run(ket).norm()) == 1.0
ket = qf.H(0).run(ket)
measure0 = qf.P0(0).run(ket)
assert qf.asarray(measure0.norm()) * 2 == ALMOST_ONE
measure1 = qf.P1(0).run(ket)
assert qf.asarray(measure1.norm()) * 2 == ALMOST_ONE
def test_purity():
density = qf.ghz_state(4).asdensity()
assert qf.asarray(qf.purity(density)) == ALMOST_ONE
for _ in range(10):
density = qf.random_density(4)
purity = np.real(qf.asarray(qf.purity(density)))
assert purity < 1.0
assert purity >= 0.0
rho = qf.Density(np.diag([0.9, 0.1]))
assert np.isclose(qf.asarray(qf.purity(rho)), 0.82) # Kudos: Josh Combes
def test_swap_test():
import examples.swaptest as ex
ket0 = qf.zero_state([0])
ket1 = qf.random_state([1])
ket2 = qf.random_state([2])
ket = qf.join_states(ket0, ket1)
ket = qf.join_states(ket, ket2)
fid = qf.state_fidelity(ket1, ket2.relabel([1]))
st_fid = ex.swap_test(ket, 0, 1, 2)
assert qf.asarray(fid) / qf.asarray(st_fid) == ALMOST_ONE
def test_trace():
data = [1] * 256
r8 = qf.QubitVector(data, range(1))
r4 = qf.QubitVector(data, range(2))
r2 = qf.QubitVector(data, range(4))
r1 = qf.QubitVector(data, range(8))
assert np.isclose(qf.asarray(r8.trace()), 16)
assert np.isclose(qf.asarray(r4.trace()), 16)
assert np.isclose(qf.asarray(r2.trace()), 16)
with pytest.raises(ValueError):
r1.trace()
def test_expectation():
ket = qf.zero_state(4)
M = np.zeros(shape=([2] * 4))
M[0, 0, 0, 0] = 42
M[1, 0, 0, 0] = 1
M[0, 1, 0, 0] = 2
M[0, 0, 1, 0] = 3
M[0, 0, 0, 1] = 4
M = bk.astensor(M)
avg = ket.expectation(M)
assert qf.asarray(avg) == 42
ket = qf.w_state(4)
assert qf.asarray(ket.expectation(M)) == 2.5
def test_biased_coin():
# sample from a 75% head and 25% tails coin
rho = qf.zero_state(1).asdensity()
chan = qf.RX(np.pi / 3, 0).aschannel()
rho = chan.evolve(rho)
prob = qf.asarray(rho.probabilities())
assert np.allclose(prob, [0.75, 0.25])
def test_state_to_density():
density = qf.ghz_state(4).asdensity()
assert list(density.vec.asarray().shape) == [2] * 8
prob = qf.asarray(density.probabilities())
assert prob[0, 0, 0, 0] - 0.5 == ALMOST_ZERO
assert prob[0, 1, 0, 0] == ALMOST_ZERO
assert prob[1, 1, 1, 1] - 0.5 == ALMOST_ZERO
ket = qf.random_state(3)
density = ket.asdensity()
ket_prob = qf.asarray(ket.probabilities())
density_prob = qf.asarray(density.probabilities())
for index, prob in np.ndenumerate(ket_prob):
assert prob - density_prob[index] == ALMOST_ZERO
def test_fubini_study_angle_states():
# The state angle is half angle in Bloch sphere
angle1 = 0.1324
ket1 = qf.zero_state(1)
ket2 = qf.RX(angle1, 0).run(ket1)
angle2 = qf.asarray(qf.fubini_study_angle(ket1.vec, ket2.vec))
assert angle1 - angle2 * 2 == ALMOST_ZERO
def test_probability():
state = qf.w_state(3)
qf.print_state(state)
prob = state.probabilities()
qf.print_probabilities(state)
assert qf.asarray(prob).sum() == ALMOST_ONE
def test_expectation():
ket = qf.zero_state(1)
ket = qf.H(0).run(ket)
m = ket.expectation([0.4, 0.6])
assert qf.asarray(m) - 0.5 == ALMOST_ZERO
m = ket.expectation([0.4, 0.6], 10)
def main():
"""CLI"""
print(swap_test.__doc__)
print('Randomly generating two 1-qubit states...')
ket0 = qf.zero_state([0])
ket1 = qf.random_state([1])
ket2 = qf.random_state([2])
ket = qf.join_states(ket0, ket1, ket2)
fid = qf.state_fidelity(ket1, ket2.relabel([1]))
st_fid = swap_test(ket, 0, 1, 2)
print('Fidelity: ', qf.asarray(fid))
print('Fidelity from swap test:', qf.asarray(st_fid))
def test_cnot():
# three cnots same as one swap
gate = qf.identity_gate(2)
gate = qf.CNOT(1, 0) @ gate
gate = qf.CNOT(0, 1) @ gate
gate = qf.CNOT(1, 0) @ gate
res = qf.asarray(qf.inner_product(gate.vec, qf.SWAP().vec))
assert abs(res) / 4 == ALMOST_ONE
def test_hadamard():
gate = qf.I()
gate = qf.RZ(pi / 2, 0) @ gate
gate = qf.RX(pi / 2, 0) @ gate
gate = qf.RZ(pi / 2, 0) @ gate
res = qf.asarray(qf.inner_product(gate.vec, qf.H().vec))
assert abs(res) / 2 == ALMOST_ONE
def test_sample_bell():
rho = qf.zero_state(2).asdensity()
chan = qf.H(0).aschannel()
rho = chan.evolve(rho)
chan = qf.CNOT(0, 1).aschannel() # TODO: chanmul
rho = chan.evolve(rho)
prob = qf.asarray(rho.probabilities())
assert np.allclose(prob, [[0.5, 0], [0, 0.5]])
def test_partial_trace():
data = [1] * (2**16)
r8 = qf.QubitVector(data, range(2))
r4 = qf.QubitVector(data, range(4))
r2 = qf.QubitVector(data, range(8))
tr2 = r2.partial_trace([1])
assert tr2.qubits == (0, 2, 3, 4, 5, 6, 7)
assert tr2.rank == 2
tr2 = r2.partial_trace([2, 3])
assert tr2.qubits == (0, 1, 4, 5, 6, 7)
assert tr2.rank == 2
tr4 = r4.partial_trace([0])
assert tr4.qubits == (1, 2, 3)
assert tr4.rank == 4
tr8 = r8.partial_trace([1])
assert tr8.qubits == (0, )
assert tr8.rank == 8
with pytest.raises(ValueError):
r2.partial_trace(range(8))
chan012 = qf.identity_gate(3).aschannel()
assert np.isclose(qf.asarray(chan012.trace()), 64) # 2**(2**3)
chan02 = chan012.partial_trace([1])
assert np.isclose(qf.asarray(chan02.trace()), 32) # TODO: Checkme
chan2 = chan012.partial_trace([0, 1])
assert np.isclose(qf.asarray(chan2.trace()), 16) # TODO: checkme
# partial traced channels should be identities still, upto normalization
assert qf.channels_close(chan2, qf.I(2).aschannel())
# TODO: Channel.normalize()
with pytest.raises(ValueError):
qf.zero_state(4).vec.partial_trace([1, 2])
def test_fubini_study_angle():
for _ in range(REPS):
theta = random.uniform(-pi, +pi)
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RX(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RY(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec, qf.RZ(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(
qf.fubini_study_angle(qf.SWAP().vec,
qf.PSWAP(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
ang = qf.asarray(qf.fubini_study_angle(qf.I().vec,
qf.PHASE(theta).vec))
assert 2 * ang / abs(theta) == ALMOST_ONE
for n in range(1, 6):
eye = qf.identity_gate(n)
assert qf.asarray(qf.fubini_study_angle(eye.vec, eye.vec)) \
== ALMOST_ZERO
with pytest.raises(ValueError):
qf.fubini_study_angle(qf.random_gate(1).vec, qf.random_gate(2).vec)
def test_measurement():
rho = qf.zero_state(2).asdensity()
chan = qf.H(0).aschannel()
rho = chan.evolve(rho)
rho = qf.Kraus([qf.P0(0), qf.P1(0)]).aschannel().evolve(rho)
K = qf.Kraus([qf.P0(1), qf.P1(1)])
chan = K.aschannel()
rho = qf.Kraus([qf.P0(1), qf.P1(1)]).aschannel().evolve(rho)
prob = qf.asarray(rho.probabilities())
assert np.allclose(prob, [[0.5, 0], [0.5, 0]])
assert prob[0, 0] * 2 == ALMOST_ONE
assert prob[1, 0] * 2 == ALMOST_ONE
def test_occupation_basis():
prog = qf.Program()
prog += qf.Call('X', [], [0])
prog += qf.Call('X', [], [1])
prog += qf.Call('I', [], [2])
prog += qf.Call('I', [], [3])
ket = prog.run()
assert ket.qubits == (0, 1, 2, 3)
probs = qf.asarray(ket.probabilities())
assert probs[1, 1, 0, 0] == 1.0
assert probs[1, 1, 0, 1] == 0.0
def test_depolarizing():
p = 1.0 - np.exp(-1 / 20)
chan = qf.Depolarizing(p, 0).aschannel()
rho0 = qf.Density([[0.5, 0], [0, 0.5]])
assert qf.densities_close(rho0, chan.evolve(rho0))
rho0 = qf.random_density(1)
rho1 = chan.evolve(rho0)
pr0 = np.real(qf.asarray(qf.purity(rho0)))
pr1 = np.real(qf.asarray(qf.purity(rho1)))
assert pr0 > pr1
# Test data extracted from refereneqvm
rho2 = qf.Density([[0.43328691, 0.48979689], [0.48979689, 0.56671309]])
rho_test = qf.Density([[0.43762509 + 0.j, 0.45794666 + 0.j],
[0.45794666 + 0.j, 0.56237491 + 0.j]])
assert qf.densities_close(chan.evolve(rho2), rho_test)
ket0 = qf.random_state(1)
qf.Depolarizing(p, 0).run(ket0)
rho1b = qf.Depolarizing(p, 0).evolve(rho0)
assert qf.densities_close(rho1, rho1b)
def test_transpose_map():
# The transpose map is a superoperator that transposes a 1-qubit
# density matrix. Not physical.
# quant-ph/0202124
ops = [
qf.Gate(np.asarray([[1, 0], [0, 0]])),
qf.Gate(np.asarray([[0, 0], [0, 1]])),
qf.Gate(np.asarray([[0, 1], [1, 0]]) / np.sqrt(2)),
qf.Gate(np.asarray([[0, 1], [-1, 0]]) / np.sqrt(2))
]
kraus = qf.Kraus(ops, weights=(1, 1, 1, -1))
rho0 = qf.random_density(1)
rho1 = kraus.evolve(rho0)
op0 = qf.asarray(rho0.asoperator())
op1 = qf.asarray(rho1.asoperator())
assert np.allclose(op0.T, op1)
# The Choi matrix should be same as SWAP operator
choi = kraus.aschannel().choi()
choi = qf.asarray(choi)
assert np.allclose(choi, qf.asarray(qf.SWAP(0, 2).asoperator()))
def test_sample_coin():
chan = qf.H(0).aschannel()
rho = qf.zero_state(1).asdensity()
rho = chan.evolve(rho)
prob = qf.asarray(rho.probabilities())
assert np.allclose(prob, [[0.5, 0.5]])
def test_identity_gate():
N = 5
eye = qf.asarray(qf.identity_gate(N).asoperator())
assert np.allclose(eye, np.eye(2**N))
def test_su():
su = qf.SWAP(0, 1).su()
assert np.linalg.det(qf.asarray(su.asoperator())) == ALMOST_ONE
def test_channel_trace():
chan = qf.I(0).aschannel()
assert np.isclose(qf.asarray(chan.trace()), 4)
def test_mixed_density():
rho = qf.mixed_density(4)
assert qf.asarray(rho.trace()) == ALMOST_ONE
