def test_unitary_dagger(backend, nqubits):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
matrix = np.random.random((2**nqubits, 2**nqubits))
gate = gates.Unitary(matrix, *range(nqubits))
c = Circuit(nqubits)
c.add((gate, gate.dagger()))
initial_state = random_state(nqubits)
final_state = c(np.copy(initial_state))
target_state = np.dot(matrix, initial_state)
target_state = np.dot(np.conj(matrix).T, target_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_variational_layer_dagger(backend, nqubits):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 2 * np.pi * np.random.random((2, nqubits))
pairs = list((i, i + 1) for i in range(0, nqubits - 1, 2))
gate = gates.VariationalLayer(range(nqubits), pairs,
gates.RY, gates.CZ,
theta[0], theta[1])
c = Circuit(nqubits)
c.add((gate, gate.dagger()))
initial_state = random_state(nqubits)
final_state = c(np.copy(initial_state))
np.testing.assert_allclose(final_state, initial_state)
qibo.set_backend(original_backend)
def test_generalizedfsim_dagger(backend):
from scipy.linalg import expm
original_backend = qibo.get_backend()
qibo.set_backend(backend)
phi = 0.2
matrix = np.random.random((2, 2))
matrix = expm(1j * (matrix + matrix.T))
gate = gates.GeneralizedfSim(0, 1, matrix, phi)
c = Circuit(2)
c.add((gate, gate.dagger()))
initial_state = random_state(2)
final_state = c(np.copy(initial_state))
np.testing.assert_allclose(final_state, initial_state)
qibo.set_backend(original_backend)
def test_x_decomposition_execution(backend, target, controls, free, use_toffolis):
"""Check that applying the decomposition is equivalent to applying the multi-control gate."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
gate = gates.X(target).controlled_by(*controls)
nqubits = max((target,) + controls + free) + 1
initial_state = random_state(nqubits)
targetc = Circuit(nqubits)
targetc.add(gate)
target_state = targetc(np.copy(initial_state))
c = Circuit(nqubits)
c.add(gate.decompose(*free, use_toffolis=use_toffolis))
final_state = c(np.copy(initial_state))
np.testing.assert_allclose(final_state, target_state, atol=1e-6)
qibo.set_backend(original_backend)
def test_collapse_gate_distributed(backend, accelerators, nqubits, targets):
"""Check :class:`qibo.core.cgates.Collapse` as part of distributed circuits."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(nqubits)
c = Circuit(nqubits, accelerators)
c.add(gates.Collapse(*targets))
final_state = c(np.copy(initial_state))
slicer = nqubits * [slice(None)]
for t in targets:
slicer[t] = 0
slicer = tuple(slicer)
initial_state = initial_state.reshape(nqubits * (2,))
target_state = np.zeros_like(initial_state)
target_state[slicer] = initial_state[slicer]
norm = (np.abs(target_state) ** 2).sum()
target_state = target_state.ravel() / np.sqrt(norm)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_u3(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta, phi, lam = 0.1, 0.1234, 0.4321
initial_state = random_state(2)
c = Circuit(2)
c.add(gates.U3(1, theta, phi, lam).controlled_by(0))
final_state = c(np.copy(initial_state))
assert c.queue[0].__class__.__name__ == "CU3"
c = Circuit(2)
c.add(gates.CU3(0, 1, theta, phi, lam))
target_state = c(np.copy(initial_state))
np.testing.assert_allclose(final_state, target_state)
# for coverage
gate = gates.U3(0, theta, phi, lam)
assert gate.parameters == (theta, phi, lam)
qibo.set_backend(original_backend)
def test_measurement_collapse(backend, nqubits, targets):
from qibo.tests_new.test_core_gates import random_state
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(nqubits)
gate = gates.M(*targets, collapse=True)
final_state = gate(np.copy(initial_state), nshots=1)
results = gate.result.binary[0]
slicer = nqubits * [slice(None)]
for t, r in zip(targets, results):
slicer[t] = r
slicer = tuple(slicer)
initial_state = initial_state.reshape(nqubits * (2, ))
target_state = np.zeros_like(initial_state)
target_state[slicer] = initial_state[slicer]
norm = (np.abs(target_state)**2).sum()
target_state = target_state.ravel() / np.sqrt(norm)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_by_random(backend, nqubits):
"""Check controlled_by method on gate."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
from qibo.models import Circuit
from qibo.tests_new.test_core_gates import random_state
initial_psi = random_state(nqubits)
initial_rho = np.outer(initial_psi, initial_psi.conj())
c = Circuit(nqubits, density_matrix=True)
c.add(gates.RX(1, theta=0.789).controlled_by(2))
c.add(gates.fSim(0, 2, theta=0.123, phi=0.321).controlled_by(1, 3))
final_rho = c(np.copy(initial_rho))
c = Circuit(nqubits)
c.add(gates.RX(1, theta=0.789).controlled_by(2))
c.add(gates.fSim(0, 2, theta=0.123, phi=0.321).controlled_by(1, 3))
target_psi = c(np.copy(initial_psi))
target_rho = np.outer(target_psi, np.conj(target_psi))
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def test_reset_channel_repeated(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(5)
c = Circuit(5)
c.add(gates.ResetChannel(2, p0=0.3, p1=0.3, seed=123))
final_state = c(np.copy(initial_state), nshots=30)
np.random.seed(123)
target_state = []
for _ in range(30):
noiseless_c = Circuit(5)
if np.random.random() < 0.3:
noiseless_c.add(gates.Collapse(2))
if np.random.random() < 0.3:
noiseless_c.add(gates.Collapse(2))
noiseless_c.add(gates.X(2))
target_state.append(noiseless_c(np.copy(initial_state)))
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_measurement_collapse_distributed(backend, accelerators, nqubits,
targets):
# TODO: Add accelerators in this test once you fix `gates.M` collapse for
# distributed circuit
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(nqubits)
c = Circuit(nqubits, accelerators)
output = c.add(gates.M(*targets, collapse=True))
result = c(np.copy(initial_state))
slicer = nqubits * [slice(None)]
for t, r in zip(targets, output.samples()[0]):
slicer[t] = r
slicer = tuple(slicer)
initial_state = initial_state.reshape(nqubits * (2, ))
target_state = np.zeros_like(initial_state)
target_state[slicer] = initial_state[slicer]
norm = (np.abs(target_state)**2).sum()
target_state = target_state.ravel() / np.sqrt(norm)
np.testing.assert_allclose(result.state(), target_state)
qibo.set_backend(original_backend)
def test_measurement_result_parameters_multiple_qubits(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
from qibo import K
from qibo.tests_new.test_core_gates import random_state
initial_state = random_state(4)
K.set_seed(123)
c = models.Circuit(4)
output = c.add(gates.M(0, 1, 2, collapse=True))
c.add(gates.RY(1, theta=np.pi * output[0] / 5))
c.add(gates.RX(3, theta=np.pi * output[2] / 3))
result = c(initial_state=np.copy(initial_state))
K.set_seed(123)
collapse = gates.M(0, 1, 2, collapse=True)
target_state = collapse(np.copy(initial_state))
if int(collapse.result.outcome(0)):
target_state = gates.RY(1, theta=np.pi / 5)(target_state)
if int(collapse.result.outcome(2)):
target_state = gates.RX(3, theta=np.pi / 3)(target_state)
np.testing.assert_allclose(result, target_state)
qibo.set_backend(original_backend)
def test_measurement_result_parameters_random(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
from qibo import K
from qibo.tests_new.test_core_gates import random_state
test_device = K.cpu_devices[0] if accelerators else K.default_device
initial_state = random_state(4)
K.set_seed(123)
c = models.Circuit(4, accelerators)
output = c.add(gates.M(1, collapse=True))
c.add(gates.RY(0, theta=np.pi * output / 5))
c.add(gates.RX(2, theta=np.pi * output / 4))
result = c(initial_state=np.copy(initial_state))
K.set_seed(123)
with K.device(test_device):
collapse = gates.M(1, collapse=True)
target_state = collapse(np.copy(initial_state))
if int(collapse.result.outcome()):
target_state = gates.RY(0, theta=np.pi / 5)(target_state)
target_state = gates.RX(2, theta=np.pi / 4)(target_state)
np.testing.assert_allclose(result, target_state)
qibo.set_backend(original_backend)
def test_reset_channel_repeated(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(5)
c = Circuit(5)
c.add(gates.ResetChannel(2, p0=0.3, p1=0.3, seed=123))
final_state = c(np.copy(initial_state), nshots=30)
np.random.seed(123)
target_state = []
collapse = gates.M(2, collapse=True)
collapse.nqubits = 5
xgate = gates.X(2)
for _ in range(30):
state = np.copy(initial_state)
if np.random.random() < 0.3:
state = K.state_vector_collapse(collapse, state, [0])
if np.random.random() < 0.3:
state = K.state_vector_collapse(collapse, state, [0])
state = xgate(state)
target_state.append(np.copy(state))
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
