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_density_angle() -> None:
rho0 = qf.random_density(1)
rho1 = qf.random_density(1)
qf.density_angle(rho0, rho1)
assert not qf.densities_close(rho0, rho1)
assert qf.densities_close(rho0, rho0)
def test_amplitude_damping():
rho = qf.zero_state(1).asdensity()
p = 1.0 - np.exp(-(50) / 15000)
chan = qf.Damping(p, 0).aschannel()
rho1 = chan.evolve(rho)
assert qf.densities_close(rho, rho1)
rho2 = qf.X(0).aschannel().evolve(rho1)
rho3 = chan.evolve(rho2)
expected = qf.Density([[0.00332778 + 0.j, 0.00000000 + 0.j],
[0.00000000 + 0.j, 0.99667222 + 0.j]])
assert qf.densities_close(expected, rho3)
def test_kraus_evolve():
rho = qf.zero_state(1).asdensity()
p = 1 - np.exp(-50 / 15000)
kraus = qf.Damping(p, 0)
rho1 = kraus.evolve(rho)
assert qf.densities_close(rho, rho1)
rho2 = qf.X(0).aschannel().evolve(rho1)
rho3 = kraus.evolve(rho2)
expected = qf.Density([[0.00332778 + 0.j, 0.00000000 + 0.j],
[0.00000000 + 0.j, 0.99667222 + 0.j]])
assert qf.densities_close(expected, rho3)
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_identity():
chan = qf.identity_gate(1).aschannel()
rho = qf.random_density(2)
after = chan.evolve(rho)
assert qf.densities_close(rho, after)
assert chan.name == 'Channel'
def test_identity() -> None:
chan = qf.IdentityGate([1]).aschannel()
rho = qf.random_density(2)
after = chan.evolve(rho)
assert qf.densities_close(rho, after)
assert chan.name == "Channel"
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_gate_evolve(gatet: Type[qf.StdGate]) -> None:
gate0 = _randomize_gate(gatet)
gate1 = qf.Unitary(gate0.tensor, gate0.qubits)
rho = qf.random_density(gate0.qubits)
rho0 = gate0.evolve(rho)
rho1 = gate1.evolve(rho)
assert qf.densities_close(rho0, rho1)
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_multiswapgate() -> None:
# Should be same as a swap.
perm0 = qf.MultiSwapGate([0, 1], [1, 0])
gate0 = qf.Swap(0, 1)
assert qf.gates_close(perm0.asgate(), gate0)
assert qf.gates_close(perm0.asgate(), perm0.H.asgate())
perm1 = qf.MultiSwapGate.from_gates(qf.Circuit([gate0]))
assert qf.gates_close(perm0.asgate(), perm1.asgate())
perm2 = qf.MultiSwapGate.from_gates(qf.Circuit([perm1]))
assert qf.gates_close(perm0, perm2)
with pytest.raises(ValueError):
qf.MultiSwapGate.from_gates(qf.Circuit(qf.CNot(0, 1)))
N = 8
qubits_in = list(range(N))
qubits_out = np.random.permutation(qubits_in)
permN = qf.MultiSwapGate(qubits_in, qubits_out)
assert qf.gates_close(perm0.asgate(), perm1.asgate())
iden = qf.Circuit([permN, permN.H])
assert qf.almost_identity(iden.asgate())
assert qf.circuits_close(iden, qf.Circuit([qf.IdentityGate(qubits_in)]))
swaps = qf.Circuit(permN.decompose())
# Add identity so we don't lose qubits
swaps += qf.IdentityGate(permN.qubits_in)
permN2 = qf.MultiSwapGate.from_gates(swaps)
assert qf.circuits_close(swaps, qf.Circuit([permN]))
assert qf.circuits_close(swaps, qf.Circuit([permN2]))
assert qf.circuits_close(qf.Circuit([permN]), qf.Circuit([permN2]))
with pytest.raises(ValueError):
_ = qf.MultiSwapGate([0, 1], [1, 2])
# Channels
assert qf.channels_close(perm0.aschannel(), gate0.aschannel())
rho0 = qf.random_state([0, 1, 3]).asdensity()
rho1 = perm0.evolve(rho0)
rho2 = gate0.aschannel().evolve(rho0)
assert qf.densities_close(rho1, rho2)
def test_kraus_run():
ket0 = qf.zero_state(['a'])
ket0 = qf.X('a').run(ket0)
p = 1.0 - np.exp(-2000 / 15000)
kraus = qf.Damping(p, 'a')
reps = 1000
results = [kraus.run(ket0).asdensity().asoperator() for _ in range(reps)]
matrix = reduce(add, results) / reps
rho_kraus = qf.Density(matrix, ['a'])
rho0 = ket0.asdensity()
chan = kraus.aschannel()
rho_chan = chan.evolve(rho0)
# If this fails occasionally consider increasing tolerance
# Can't be very tolerant due to stochastic dynamics
assert qf.densities_close(rho_chan, rho_kraus, tolerance=0.05)
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)
