def test_fidelity() -> None:
rho0 = qf.random_density(4)
rho1 = qf.random_density(4)
fid = qf.fidelity(rho0, rho1)
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)
assert np.isclose(fid, 1.0)
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 np.isclose(fid1, fid0)
fid2 = np.cos(qf.fubini_study_angle(ket0.tensor, ket1.tensor)) ** 2
assert np.isclose(fid2, fid0)
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_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_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_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.on(1))
st_fid = ex.swap_test(ket, 0, 1, 2)
assert np.isclose(fid, st_fid)
def test_depolarizing() -> None:
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.purity(rho0))
pr1 = np.real(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.0j, 0.45794666 + 0.0j], [0.45794666 + 0.0j, 0.56237491 + 0.0j]]
)
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_bures_angle() -> None:
rho = qf.random_density(4)
assert np.isclose(qf.bures_angle(rho, rho), 0.0, atol=ATOL * 10)
rho1 = qf.random_density(4)
qf.bures_angle(rho, rho1)
ket0 = qf.random_state(4)
ket1 = qf.random_state(4)
rho0 = ket0.asdensity()
rho1 = ket1.asdensity()
ang0 = qf.fubini_study_angle(ket0.tensor, ket1.tensor)
ang1 = qf.bures_angle(rho0, rho1)
assert np.isclose(ang0, ang1)
def test_bures_angle():
rho = qf.random_density(4)
assert qf.bures_angle(rho, rho) == ALMOST_ZERO
rho1 = qf.random_density(4)
qf.bures_angle(rho, rho1)
ket0 = qf.random_state(4)
ket1 = qf.random_state(4)
rho0 = ket0.asdensity()
rho1 = ket1.asdensity()
ang0 = qf.fubini_study_angle(ket0.vec, ket1.vec)
ang1 = qf.bures_angle(rho0, rho1)
assert np.isclose(ang0, ang1)
def test_ccnot_circuit_evolve():
rho0 = qf.random_state(3).asdensity()
rho1 = qf.CCNOT(0, 1, 2).evolve(rho0)
rho2 = qf.ccnot_circuit([0, 1, 2]).evolve(rho0)
assert qf.densities_close(rho1, rho2)
qf.ccnot_circuit([0, 1, 2]).evolve()
def test_ccnot_circuit_evolve() -> None:
rho0 = qf.random_state(3).asdensity()
gate = qf.CCNot(0, 1, 2)
circ = qf.Circuit(qf.translate_ccnot_to_cnot(gate))
rho1 = gate.evolve(rho0)
rho2 = circ.evolve(rho0)
assert qf.densities_close(rho1, rho2)
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_gradients() -> None:
# This test only checks that code runs, not that we get correct answers
# graph = nx.grid_graph([2, 3])
graph = nx.grid_graph([2, 1])
layers = 2
params = qf.graph_circuit_params(graph, layers)
circ = qf.graph_circuit(graph, layers, params)
circ += qf.H((1, 1)) # add a non-parameterized gate. Should be ignored
qubits = circ.qubits
ket0 = qf.zero_state(qubits)
ket1 = qf.random_state(qubits)
grads0 = qf.state_fidelity_gradients(ket0, ket1, circ)
# print(grads0)
_ = qf.state_angle_gradients(ket0, ket1, circ)
# print(grads1)
proj = qf.Projection([ket1])
grads2 = qf.expectation_gradients(ket0, circ, hermitian=proj)
# print(grads2)
# Check that qf.expectation_gradients() gives same answers for
# fidelity as f.state_fidelity_gradients()
for g0, g1 in zip(grads0, grads2):
assert np.isclose(g0, g1)
print(g0, g1)
def test_density() -> None:
ket = qf.random_state(3)
matrix = qf.tensors.outer(ket.tensor, np.conj(ket.tensor), rank=1)
qf.Density(matrix)
qf.Density(matrix, [0, 1, 2])
with pytest.raises(ValueError):
qf.Density(matrix, [0, 1, 2, 3])
def test_normalize() -> None:
ket = qf.random_state(2)
assert np.isclose(ket.norm(), 1.0)
ket = qf.P0(0).run(ket)
assert ket.norm() < 1.0
ket = ket.normalize()
assert np.isclose(ket.norm(), 1.0)
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_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_evolve() -> None:
rho0 = qf.random_state(3).asdensity()
rho1 = qf.CCNot(0, 1, 2).evolve(rho0)
dag = qf.DAGCircuit(qf.translate_ccnot_to_cnot(qf.CCNot(0, 1, 2)))
rho2 = dag.evolve(rho0)
assert qf.densities_close(rho1, rho2)
def test_density():
ket = qf.random_state(3)
matrix = bk.outer(ket.tensor, bk.conj(ket.tensor))
qf.Density(matrix)
qf.Density(matrix, [0, 1, 2])
with pytest.raises(ValueError):
qf.Density(matrix, [0, 1, 2, 3])
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 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)
ket = qf.join_states(ket, ket2)
fid = qf.state_fidelity(ket1, ket2.on(1))
st_fid = swap_test(ket, 0, 1, 2)
print("Fidelity: ", fid)
print("Fidelity from swap test:", st_fid)
def test_aschannel():
rho0 = qf.random_state(3).asdensity()
rho1 = qf.CCNOT(0, 1, 2).evolve(rho0)
dag = qf.DAGCircuit(qf.ccnot_circuit([0, 1, 2]))
chan = dag.aschannel()
rho2 = chan.evolve(rho0)
assert qf.densities_close(rho1, rho2)
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_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_density():
ket = qf.random_state(3)
matrix = bk.outer(ket.tensor, bk.conj(ket.tensor))
qf.Density(matrix)
rho = qf.Density(matrix, [0, 1, 2])
with pytest.raises(ValueError):
qf.Density(matrix, [0, 1, 2, 3])
assert rho.asdensity() is rho
rho = rho.relabel([10, 11, 12]).permute([12, 11, 10])
assert rho.qubits == (12, 11, 10)
def test_density() -> None:
ket = qf.random_state(3)
matrix = np.outer(ket.tensor, np.conj(ket.tensor))
qf.Density(matrix)
rho = qf.Density(matrix, [0, 1, 2])
with pytest.raises(ValueError):
qf.Density(matrix, [0, 1, 2, 3])
assert rho.asdensity() is rho
rho = rho.on(10, 11, 12).permute([12, 11, 10])
assert rho.qubits == (12, 11, 10)
rho.permute()
def test_gradient_errors() -> None:
circ = qf.Circuit()
circ += qf.CPhase(0.2, 0, 1) # Not (currently) differentiable
qubits = circ.qubits
ket0 = qf.zero_state(qubits)
ket1 = qf.random_state(qubits)
with pytest.raises(ValueError):
qf.state_fidelity_gradients(ket0, ket1, circ)
with pytest.raises(ValueError):
qf.parameter_shift_circuits(circ, 0)
with pytest.raises(ValueError):
qf.expectation_gradients(ket0, circ, qf.IdentityGate([0, 1]))
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_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_state_to_density() -> None:
density = qf.ghz_state(4).asdensity()
assert density.tensor.shape == (2, ) * 8
prob = density.probabilities()
assert np.isclose(prob[0, 0, 0, 0], 0.5)
assert np.isclose(prob[0, 1, 0, 0], 0)
assert np.isclose(prob[1, 1, 1, 1], 0.5)
ket = qf.random_state(3)
density = ket.asdensity()
ket_prob = ket.probabilities()
density_prob = density.probabilities()
for index, prob in np.ndenumerate(ket_prob):
assert np.isclose(prob, density_prob[index])
