def test_circuit_with_noise_with_measurements(backend):
"""Check ``circuit.with_noise() when using measurement noise."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1)])
c.add(gates.M(0))
noisy_c = c.with_noise(3 * (0.1, ))
target_c = models.Circuit(2, density_matrix=True)
target_c.add(gates.H(0))
target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.1, 0.1))
target_c.add(gates.H(1))
target_c.add(gates.PauliNoiseChannel(1, 0.1, 0.1, 0.1))
final_state = noisy_c().numpy()
target_state = target_c().numpy()
np.testing.assert_allclose(target_state, final_state)
qibo.set_backend(original_backend)
def test_doubly_controlled_by_rx(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(3, accelerators)
c.add(gates.RX(2, theta))
target_state = c.execute().numpy()
c = Circuit(3)
c.add(gates.X(0))
c.add(gates.X(1))
c.add(gates.RX(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
c.add(gates.X(1))
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_cz(backend):
"""Check CZ gate is working properly on random state."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
init_state = utils.random_numpy_state(2)
matrix = np.eye(4)
matrix[3, 3] = -1
target_state = matrix.dot(init_state)
c = Circuit(2)
c.add(gates.CZ(0, 1))
final_state = c.execute(np.copy(init_state)).numpy()
np.testing.assert_allclose(final_state, target_state)
c = Circuit(2)
c.add(gates.Z(1).controlled_by(0))
final_state = c.execute(np.copy(init_state)).numpy()
assert c.queue[0].name == "cz"
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_u2(backend):
"""Check U2 gate on random state."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
phi = 0.1234
lam = 0.4321
initial_state = utils.random_numpy_state(1)
c = Circuit(1)
c.add(gates.U2(0, phi, lam))
final_state = c(np.copy(initial_state))
matrix = np.array(
[[np.exp(-1j * (phi + lam) / 2), -np.exp(-1j * (phi - lam) / 2)],
[np.exp(1j * (phi - lam) / 2),
np.exp(1j * (phi + lam) / 2)]])
target_state = matrix.dot(initial_state) / np.sqrt(2)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_vqe(method, options, compile, filename):
"""Performs a VQE circuit minimization test."""
import qibo
original_backend = qibo.get_backend()
if method == "sgd" or compile:
qibo.set_backend("matmuleinsum")
else:
qibo.set_backend("custom")
nqubits = 6
layers = 4
circuit = Circuit(nqubits)
for l in range(layers):
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(0, nqubits - 1, 2):
circuit.add(gates.CZ(q, q + 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
for q in range(1, nqubits - 2, 2):
circuit.add(gates.CZ(q, q + 1))
circuit.add(gates.CZ(0, nqubits - 1))
for q in range(nqubits):
circuit.add(gates.RY(q, theta=1.0))
hamiltonian = XXZ(nqubits=nqubits)
np.random.seed(0)
initial_parameters = np.random.uniform(0, 2 * np.pi,
2 * nqubits * layers + nqubits)
v = VQE(circuit, hamiltonian)
best, params = v.minimize(initial_parameters,
method=method,
options=options,
compile=compile)
if method == "cma":
# remove `outcmaes` folder
import shutil
shutil.rmtree("outcmaes")
if filename is not None:
utils.assert_regression_fixture(params, filename)
qibo.set_backend(original_backend)
def test_multicontrol_xgate_more_controls(backend, accelerators):
"""Check that fallback method for X works for more than two controls."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4, accelerators)
c.add(gates.X(0))
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.X(3).controlled_by(0, 1, 2))
c.add(gates.X(0))
c.add(gates.X(2))
final_state = c.execute().numpy()
c = Circuit(4)
c.add(gates.X(1))
c.add(gates.X(3))
target_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_bad_initial_state(backend, accelerators):
"""Check that errors are raised when bad initial state is passed."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
import tensorflow as tf
c = Circuit(2, accelerators)
c.add([gates.H(0), gates.H(1)])
with pytest.raises(ValueError):
final_state = c(initial_state=np.zeros(2**3))
with pytest.raises(ValueError):
final_state = c(initial_state=np.zeros((2, 2)))
with pytest.raises(ValueError):
final_state = c(initial_state=np.zeros((2, 2, 2)))
with pytest.raises(TypeError):
final_state = c(initial_state=0)
c = Circuit(2, accelerators)
c.check_initial_state_shape = False
with pytest.raises(TypeError):
final_state = c(initial_state=0)
qibo.set_backend(original_backend)
def test_grover_execute(backend, num_sol):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
def check(result):
for i in result:
if int(i) != 1:
return False
return True
oracle = Circuit(5 + 1)
oracle.add(gates.X(5).controlled_by(*range(5)))
grover = Grover(oracle, superposition_qubits=5, check=check, number_solutions=num_sol)
solution, iterations = grover(freq=True, logs=True)
if num_sol:
assert solution == ["11111"]
assert iterations == 4
else:
assert solution == "11111"
qibo.set_backend(original_backend)
def test_density_matrix_measurement(backend):
"""Check measurement gate on density matrices."""
from qibo.tests_new.test_measurement_gate import assert_result
original_backend = qibo.get_backend()
qibo.set_backend(backend)
state = np.zeros(4)
state[2] = 1
rho = np.outer(state, state.conj())
mgate = gates.M(0, 1)
mgate.density_matrix = True
result = mgate(rho, nshots=100)
target_binary_samples = np.zeros((100, 2))
target_binary_samples[:, 0] = 1
assert_result(result,
decimal_samples=2 * np.ones((100, )),
binary_samples=target_binary_samples,
decimal_frequencies={2: 100},
binary_frequencies={"10": 100})
qibo.set_backend(original_backend)
def test_circuit_switch_to_density_matrix(backend):
"""Test that using `gates.NoiseChnanel` switches vector to density matrix."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.NoiseChannel(0, px=0.5))
c.add(gates.NoiseChannel(1, pz=0.3))
final_rho = c().numpy()
psi = np.ones(4) / 2
initial_rho = np.outer(psi, psi.conj())
c = models.Circuit(2)
c.add(gates.NoiseChannel(0, px=0.5))
c.add(gates.NoiseChannel(1, pz=0.3))
target_rho = c(initial_rho).numpy()
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def test_circuit_addition_execution(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(4, accelerators)
c1.add(gates.H(0))
c1.add(gates.H(1))
c1.add(gates.H(2))
c2 = Circuit(4, accelerators)
c2.add(gates.CNOT(0, 1))
c2.add(gates.CZ(2, 3))
c3 = c1 + c2
c = Circuit(4, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.H(2))
c.add(gates.CNOT(0, 1))
c.add(gates.CZ(2, 3))
np.testing.assert_allclose(c3(), c())
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_from_qasm_measurements(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
target = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[5];
creg a[3];
creg b[2];
measure q[0] -> a[0];
x q[3];
measure q[1] -> b[0];
measure q[2] -> a[1];
measure q[4] -> a[2];
measure q[3] -> b[1];"""
c = Circuit.from_qasm(target)
assert c.depth == 1
assert isinstance(c.queue[0], gates.X)
assert isinstance(c.measurement_gate, gates.M)
assert c.measurement_tuples == {"a": (0, 2, 4), "b": (1, 3)}
qibo.set_backend(original_backend)
def test_set_backend(backend):
"""Check ``set_backend`` for switching gate backends."""
import qibo
original_backend = qibo.get_backend()
qibo.set_backend(backend)
from qibo import gates
if backend == "custom":
from qibo.tensorflow import cgates as custom_gates
assert isinstance(gates.H(0), custom_gates.TensorflowGate)
else:
from qibo.tensorflow import gates as native_gates
from qibo.tensorflow import einsum
einsums = {
"defaulteinsum": einsum.DefaultEinsum,
"matmuleinsum": einsum.MatmulEinsum
}
h = gates.H(0)
assert isinstance(h, native_gates.TensorflowGate)
assert isinstance(h.einsum, einsums[backend]) # pylint: disable=no-member
qibo.set_backend(original_backend)
def test_entropy_in_circuit(backend, density_matrix):
"""Check that entropy calculation works in circuit."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
entropy = callbacks.EntanglementEntropy([0], compute_spectrum=True)
c = Circuit(2, density_matrix=density_matrix)
c.add(gates.CallbackGate(entropy))
c.add(gates.H(0))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
state = c()
target = [0, 0, 1.0]
np.testing.assert_allclose(entropy[:], target, atol=_atol)
target_spectrum = [0, 0, np.log(2), np.log(2)]
entropy_spectrum = np.concatenate(entropy.spectrum).ravel().tolist()
np.testing.assert_allclose(entropy_spectrum, target_spectrum, atol=_atol)
qibo.set_backend(original_backend)
def test_vector_state_state_deepcopy(deep):
"""Check if deep copy is really deep."""
# use numpy backend as tensorflow tensors are immutable and cannot
# change their value for testing
import qibo
original_backend = qibo.get_backend()
qibo.set_backend("numpy")
vector = np.random.random(32) + 1j * np.random.random(32)
vector = vector / np.sqrt((np.abs(vector) ** 2).sum())
state = states.VectorState.from_tensor(vector)
cstate = state.copy(deep)
current_value = state.tensor[0]
state.tensor[0] = 0
if deep:
K.assert_allclose(state.tensor[0], 0)
K.assert_allclose(cstate.tensor[0], current_value)
K.assert_allclose(cstate.tensor[1:], state.tensor[1:])
else:
K.assert_allclose(cstate.tensor, state.tensor)
qibo.set_backend(original_backend)
def test_circuit_invert_and_addition_execution(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_controlled_swap(backend, applyx, free_qubit):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
f = int(free_qubit)
c = Circuit(3 + f)
if applyx:
c.add(gates.X(0))
c.add(gates.RX(1 + f, theta=0.1234))
c.add(gates.RY(2 + f, theta=0.4321))
c.add(gates.SWAP(1 + f, 2 + f).controlled_by(0))
final_state = c.execute()
c = Circuit(3 + f)
c.add(gates.RX(1 + f, theta=0.1234))
c.add(gates.RY(2 + f, theta=0.4321))
if applyx:
c.add(gates.X(0))
c.add(gates.SWAP(1 + f, 2 + f))
target_state = c.execute()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_by_simple(backend):
"""Check controlled_by method on gate."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
psi = np.zeros(4)
psi[0] = 1
initial_rho = np.outer(psi, psi.conj())
c = models.Circuit(2)
c.add(gates.X(0))
c.add(gates.Y(1).controlled_by(0))
final_rho = c(np.copy(initial_rho)).numpy()
c = models.Circuit(2)
c.add(gates.X(0))
c.add(gates.Y(1))
target_rho = c(np.copy(initial_rho)).numpy()
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def test_simple_cirq(backend):
import qibo
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(2)
c1.add(gates.H(0))
c1.add(gates.H(1))
final_state_c1 = c1()
c2 = circuit_from_qasm(c1.to_qasm())
c2depth = len(cirq.Circuit(c2.all_operations()))
assert c1.depth == c2depth
final_state_c2 = cirq.Simulator().simulate(c2).final_state_vector
np.testing.assert_allclose(final_state_c1, final_state_c2, atol=_atol)
c3 = Circuit.from_qasm(c2.to_qasm())
assert c3.depth == c2depth
final_state_c3 = c3()
np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
qibo.set_backend(original_backend)
def test_circuit_with_noise_execution():
"""Check ``circuit.with_noise()`` execution."""
original_backend = qibo.get_backend()
qibo.set_backend("matmuleinsum")
c = models.Circuit(2)
c.add([gates.H(0), gates.H(1)])
noisy_c = c.with_noise((0.1, 0.2, 0.3))
target_c = models.Circuit(2)
target_c.add(gates.H(0))
target_c.add(gates.NoiseChannel(0, 0.1, 0.2, 0.3))
target_c.add(gates.NoiseChannel(1, 0.1, 0.2, 0.3))
target_c.add(gates.H(1))
target_c.add(gates.NoiseChannel(0, 0.1, 0.2, 0.3))
target_c.add(gates.NoiseChannel(1, 0.1, 0.2, 0.3))
final_state = noisy_c().numpy()
target_state = target_c().numpy()
np.testing.assert_allclose(target_state, final_state)
qibo.set_backend(original_backend)
def test_circuit_gate_generator_errors(backend, accelerators):
from qibo import callbacks
original_backend = qibo.get_backend()
qibo.set_backend(backend)
smallc = Circuit(2, accelerators=accelerators)
smallc.add((gates.H(i) for i in range(2)))
with pytest.raises(ValueError):
next(smallc.on_qubits(0, 1, 2))
smallc = Circuit(2, accelerators=accelerators)
smallc.add(gates.Flatten(np.ones(4) / np.sqrt(2)))
with pytest.raises(NotImplementedError):
next(smallc.on_qubits(0, 1))
smallc = Circuit(4, accelerators=accelerators)
smallc.add(gates.CallbackGate(callbacks.EntanglementEntropy([0, 1])))
with pytest.raises(NotImplementedError):
next(smallc.on_qubits(0, 1, 2, 3))
qibo.set_backend(original_backend)
def test_generalizedfsim_dagger(backend, tfmatrix):
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))
if tfmatrix:
import tensorflow as tf
from qibo.config import DTYPES
matrix = tf.cast(matrix, dtype=DTYPES.get('DTYPECPX'))
gate = gates.GeneralizedfSim(0, 1, matrix, phi)
c = Circuit(2)
c.add((gate, gate.dagger()))
initial_state = utils.random_numpy_state(2)
final_state = c(np.copy(initial_state)).numpy()
np.testing.assert_allclose(final_state, initial_state)
qibo.set_backend(original_backend)
def test_collapse_gate(backend, nqubits, targets, results):
from qibo import K
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(nqubits)
collapse = gates.Collapse(*targets, result=results)
final_state = apply_gates([collapse], initial_state=np.copy(initial_state))
if isinstance(results, int) or isinstance(results, K.numeric_types):
results = nqubits * [results]
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_grover_init(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
oracle = Circuit(5 + 1)
oracle.add(gates.X(5).controlled_by(*range(5)))
superposition = Circuit(5)
superposition.add([gates.H(i) for i in range(5)])
grover = Grover(oracle, superposition_circuit=superposition)
assert grover.oracle == oracle
assert grover.superposition == superposition
assert grover.sup_qubits == 5
assert grover.sup_size == 32
assert not grover.iterative
grover = Grover(oracle, superposition_circuit=superposition, superposition_size=int(2**5))
assert grover.oracle == oracle
assert grover.superposition == superposition
assert grover.sup_qubits == 5
assert grover.sup_size == 32
assert not grover.iterative
qibo.set_backend(original_backend)
def test_measurement_compiled_circuit(backend):
if backend == "custom":
# use native gates because custom gates do not support compilation
pytest.skip("Custom backend does not support compilation.")
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2)
c.add(gates.X(0))
c.add(gates.M(0))
c.add(gates.M(1))
result = c(nshots=100)
target_binary_samples = np.zeros((100, 2))
target_binary_samples[:, 0] = 1
assert_result(result, 2 * np.ones((100, )), target_binary_samples,
{2: 100}, {"10": 100})
target_state = np.zeros_like(c.final_state)
target_state[2] = 1
np.testing.assert_allclose(c.final_state, target_state)
qibo.set_backend(original_backend)
def test_circuit_addition_result(backend, accelerators):
"""Check if circuit addition works properly on Tensorflow circuit."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(2, accelerators)
c1.add(gates.H(0))
c1.add(gates.H(1))
c2 = Circuit(2, accelerators)
c2.add(gates.CNOT(0, 1))
c3 = c1 + c2
c = Circuit(2, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.CNOT(0, 1))
np.testing.assert_allclose(c3.execute().numpy(), c.execute().numpy())
qibo.set_backend(original_backend)
def test_final_state(backend, accelerators):
"""Check that final state is logged correctly when using measurements."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(4, accelerators)
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.M(0, 1))
c.add(gates.M(2))
c.add(gates.X(3))
result = c(nshots=100)
c = models.Circuit(4, accelerators)
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.X(3))
target_state = c()
np.testing.assert_allclose(c.final_state, target_state)
qibo.set_backend(original_backend)
def test_generalized_fsim(backend, accelerators):
"""Check GeneralizedfSim gate is working properly on |++>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
phi = np.random.random()
rotation = utils.random_numpy_complex((2, 2))
c = Circuit(3, accelerators)
c.add((gates.H(i) for i in range(3)))
c.add(gates.GeneralizedfSim(1, 2, rotation, phi))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / np.sqrt(8)
matrix = np.eye(4, dtype=target_state.dtype)
matrix[1:3, 1:3] = rotation
matrix[3, 3] = np.exp(-1j * phi)
target_state[:4] = matrix.dot(target_state[:4])
target_state[4:] = matrix.dot(target_state[4:])
np.testing.assert_allclose(final_state, target_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)
