def test_controlled_rotations_from_un(backend, name, params):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
init_state = utils.random_numpy_state(2)
gate = getattr(gates, name)(0, 1, **params)
c = Circuit(2)
c.add(gate)
target_state = c(np.copy(init_state)).numpy()
final_state = gate.unitary.numpy().dot(init_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_repeated_execute(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4, accelerators)
thetas = np.random.random(4)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
c.repeated_execution = True
target_state = np.array(20 * [c()])
final_state = c(nshots=20)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_set_nqubits(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4)
c.add(gates.H(0))
assert c.queue[0].nqubits == 4
gate = gates.H(1)
gate.nqubits = 3
with pytest.raises(RuntimeError):
c.add(gate)
qibo.set_backend(original_backend)
def test_controlled_by_gates_fusion(backend):
"""Check circuit fusion that contains ``controlled_by`` gates."""
c = Circuit(4)
c.add((gates.H(i) for i in range(4)))
c.add(gates.RX(1, theta=0.1234).controlled_by(0))
c.add(gates.RX(3, theta=0.4321).controlled_by(2))
c.add((gates.RY(i, theta=0.5678) for i in range(4)))
c.add(gates.RX(1, theta=0.1234).controlled_by(0))
c.add(gates.RX(3, theta=0.4321).controlled_by(2))
fused_c = c.fuse()
K.assert_allclose(fused_c(), c())
def test_variational_layer_dagger(backend, nqubits):
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))
K.assert_allclose(final_state, initial_state)
def test_generalizedfsim_dagger(backend):
from scipy.linalg import expm
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))
K.assert_allclose(final_state, initial_state)
def test_dagger(backend, gate, args):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
gate = getattr(gates, gate)(*args)
nqubits = len(gate.qubits)
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_collapse_after_measurement(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
qubits = [0, 2, 3]
c = Circuit(5)
c.add((gates.H(i) for i in range(5)))
output = c.add(gates.M(*qubits, collapse=True))
c.add((gates.H(i) for i in range(5)))
result = c()
bitstring = output.samples()[0]
final_state = result.state()
ct = Circuit(5)
for i, r in zip(qubits, bitstring):
if r:
ct.add(gates.X(i))
ct.add((gates.H(i) for i in qubits))
target_state = ct()
np.testing.assert_allclose(final_state, target_state, atol=1e-15)
qibo.set_backend(original_backend)
def _create_circuit(self, dt, accelerators=None, memory_device="/CPU:0"):
"""Creates circuit that implements the Trotterized evolution."""
from qibo.models import Circuit
self._circuit = Circuit(self.nqubits, accelerators=accelerators,
memory_device=memory_device)
self._circuit.check_initial_state_shape = False
self._circuit.dt = None
for part in itertools.chain(self.parts, self.parts[::-1]):
for targets, term in part.items():
gate = gates.Unitary(term.exp(dt / 2.0), *targets)
self.expgate_sets[term].add(gate)
self._circuit.add(gate)
def test_circuit_invert_with_addition(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
subroutine = Circuit(6)
subroutine.add([gates.RX(i, theta=0.1) for i in range(5)])
subroutine.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
middle = Circuit(6)
middle.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)])
circuit = subroutine + middle + subroutine.invert()
c = Circuit(6)
c.add([gates.RX(i, theta=0.1) for i in range(5)])
c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
c.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)])
c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
c.add([gates.RX(i, theta=-0.1) for i in range(5)])
assert c.depth == circuit.depth
np.testing.assert_allclose(circuit(), c())
qibo.set_backend(original_backend)
def test_toffoli_no_effect(backend):
"""Check Toffoli gate is working properly on |010>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(3)
c.add(gates.X(1))
c.add(gates.TOFFOLI(0, 1, 2))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[2] = 1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_swap(backend):
"""Check SWAP gate is working properly on |01>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.X(1))
c.add(gates.SWAP(0, 1))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[2] = 1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_get_initial_state(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
final_state = c.get_initial_state()
target_state = np.zeros(4)
target_state[0] = 1
np.testing.assert_allclose(final_state, target_state)
with pytest.raises(ValueError):
state = c.get_initial_state(np.zeros(2**3))
with pytest.raises(ValueError):
final_state = c.get_initial_state(np.zeros((2, 2)))
with pytest.raises(ValueError):
final_state = c.get_initial_state(np.zeros((2, 2, 2)))
with pytest.raises(TypeError):
final_state = c.get_initial_state(0)
c = Circuit(2)
c.check_initial_state_shape = False
with pytest.raises(TypeError):
final_state = c.get_initial_state(0)
qibo.set_backend(original_backend)
def test_controlled_by_unitary_action(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
init_state = utils.random_numpy_state(2)
matrix = utils.random_numpy_complex((2, 2))
gate = gates.Unitary(matrix, 1).controlled_by(0)
c = Circuit(2)
c.add(gate)
target_state = c(np.copy(init_state)).numpy()
final_state = gate.unitary.numpy().dot(init_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_dagger_one_qubit(backend, gate, params):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(1)
gate = getattr(gates, gate)(0, **params)
c.add((gate, gate.dagger()))
initial_state = utils.random_numpy_state(1)
final_state = c(np.copy(initial_state)).numpy()
np.testing.assert_allclose(final_state, initial_state)
qibo.set_backend(original_backend)
def test_circuit_decompose_execution(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(6)
c.add(gates.RX(0, 0.1234))
c.add(gates.RY(1, 0.4321))
c.add((gates.H(i) for i in range(2, 6)))
c.add(gates.CNOT(0, 1))
c.add(gates.X(3).controlled_by(0, 1, 2, 4))
decomp_c = c.decompose(5)
np.testing.assert_allclose(c(), decomp_c(), atol=1e-6)
qibo.set_backend(original_backend)
def test_circuit_add_layer(backend, nqubits, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(nqubits, accelerators)
qubits = list(range(nqubits))
pairs = [(2 * i, 2 * i + 1) for i in range(nqubits // 2)]
params = nqubits * [0.1]
c.add(gates.VariationalLayer(qubits, pairs, gates.RY, gates.CZ, params))
assert len(c.queue) == nqubits // 2 + nqubits % 2
for gate in c.queue:
assert isinstance(gate, gates.Unitary)
qibo.set_backend(original_backend)
def test_distributed_circuit_execution_controlled_gate(backend, accelerators):
dist_c = DistributedCircuit(4, accelerators)
dist_c.add((gates.H(i) for i in range(dist_c.nglobal, 4)))
dist_c.add(gates.CNOT(0, 2))
c = Circuit(4)
c.add((gates.H(i) for i in range(dist_c.nglobal, 4)))
c.add(gates.CNOT(0, 2))
initial_state = random_state(c.nqubits)
final_state = dist_c(np.copy(initial_state))
target_state = c(np.copy(initial_state))
np.testing.assert_allclose(target_state, final_state)
def test_repeated_execute_with_noise(backend):
thetas = np.random.random(4)
c = Circuit(4)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
noisy_c = c.with_noise((0.2, 0.0, 0.1))
np.random.seed(1234)
final_state = noisy_c(nshots=20)
np.random.seed(1234)
target_state = []
for _ in range(20):
noiseless_c = Circuit(4)
for i, t in enumerate(thetas):
noiseless_c.add(gates.RY(i, theta=t))
if np.random.random() < 0.2:
noiseless_c.add(gates.X(i))
if np.random.random() < 0.1:
noiseless_c.add(gates.Z(i))
target_state.append(noiseless_c())
target_state = np.stack(target_state)
K.assert_allclose(final_state, target_state)
def test_dagger_controlled_by(backend, gate, params):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4)
gate = getattr(gates, gate)(3, **params).controlled_by(0, 1, 2)
c.add((gate, gate.dagger()))
initial_state = utils.random_numpy_state(4)
final_state = c(np.copy(initial_state)).numpy()
np.testing.assert_allclose(final_state, initial_state)
qibo.set_backend(original_backend)
def test_copied_circuit_execution(backend, accelerators, deep):
"""Check that circuit copy execution is equivalent to original circuit."""
theta = 0.1234
c1 = Circuit(4, accelerators)
c1.add([gates.X(0), gates.X(1), gates.CU1(0, 1, theta)])
c1.add([gates.H(2), gates.H(3), gates.CU1(2, 3, theta)])
if not deep and accelerators is not None:
with pytest.raises(ValueError):
c2 = c1.copy(deep)
else:
c2 = c1.copy(deep)
K.assert_allclose(c2(), c1())
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_controlled_with_effect(backend):
"""Check controlled_by SWAP that should be applied."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
from qibo.models import Circuit
initial_rho = np.zeros((16, 16))
initial_rho[0, 0] = 1
c = Circuit(4, density_matrix=True)
c.add(gates.X(0))
c.add(gates.X(2))
c.add(gates.SWAP(1, 3).controlled_by(0, 2))
final_rho = c(np.copy(initial_rho)).numpy()
c = Circuit(4, density_matrix=True)
c.add(gates.X(0))
c.add(gates.X(2))
c.add(gates.SWAP(1, 3))
target_rho = c(np.copy(initial_rho)).numpy()
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def test_cnot(backend):
"""Check CNOT gate is working properly on |10>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.X(0))
c.add(gates.CNOT(0, 1))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[3] = 1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_swap_double(backend, applyx):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4)
c.add(gates.X(0))
if applyx:
c.add(gates.X(3))
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
c.add(gates.SWAP(1, 2).controlled_by(0, 3))
c.add(gates.X(0))
final_state = c.execute()
c = Circuit(4)
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
if applyx:
c.add(gates.X(3))
c.add(gates.SWAP(1, 2))
target_state = c.execute()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_flatten(backend):
"""Check ``Flatten`` gate works in circuits ."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
target_state = np.ones(4) / 2.0
c = Circuit(2)
c.add(gates.Flatten(target_state))
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
gate = gates.Flatten(target_state)
gate(final_state)
qibo.set_backend(original_backend)
def test_controlled_unitary_matrix(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(2)
matrix = np.random.random((2, 2))
gate = gates.Unitary(matrix, 1).controlled_by(0)
c = Circuit(2)
c.add(gate)
target_state = c(np.copy(initial_state))
final_state = np.dot(gate.unitary, initial_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_variable_theta(backend, accelerators):
"""Check that parametrized gates accept `tf.Variable` parameters."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
import tensorflow as tf
from qibo.config import DTYPES
theta1 = tf.Variable(0.1234, dtype=DTYPES.get('DTYPE'))
theta2 = tf.Variable(0.4321, dtype=DTYPES.get('DTYPE'))
cvar = Circuit(2, accelerators)
cvar.add(gates.RX(0, theta1))
cvar.add(gates.RY(1, theta2))
final_state = cvar().numpy()
c = Circuit(2)
c.add(gates.RX(0, 0.1234))
c.add(gates.RY(1, 0.4321))
target_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_getitem_bad_indexing(backend):
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2)
c.add(gates.RY(0, 0.1234))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
final_state = c()
entropy[0]
with pytest.raises(IndexError):
entropy[1]
with pytest.raises(IndexError):
entropy["a"]
def test_entropy_large_circuit(accelerators):
"""Check that entropy calculation works for variational like circuit."""
thetas = np.pi * np.random.random((3, 8))
target_entropy = callbacks.EntanglementEntropy([0, 2, 4, 5])
c1 = Circuit(8)
c1.add((gates.RY(i, thetas[0, i]) for i in range(8)))
c1.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
state1 = c1()
e1 = target_entropy(state1)
c2 = Circuit(8)
c2.add((gates.RY(i, thetas[1, i]) for i in range(8)))
c2.add((gates.CZ(i, i + 1) for i in range(1, 7, 2)))
c2.add(gates.CZ(0, 7))
state2 = (c1 + c2)()
e2 = target_entropy(state2)
c3 = Circuit(8)
c3.add((gates.RY(i, thetas[2, i]) for i in range(8)))
c3.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
state3 = (c1 + c2 + c3)()
e3 = target_entropy(state3)
entropy = callbacks.EntanglementEntropy([0, 2, 4, 5])
c = Circuit(8, accelerators)
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[0, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[1, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(1, 7, 2)))
c.add(gates.CZ(0, 7))
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[2, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
c.add(gates.CallbackGate(entropy))
state = c()
np.testing.assert_allclose(state3.numpy(), state.numpy())
np.testing.assert_allclose(entropy[:].numpy(), [0, e1, e2, e3])
