def test_thermal_error(backend, density_matrix):
thermal = ThermalRelaxationError(2, 1, 0.3)
noise = NoiseModel()
noise.add(thermal, gates.X, 1)
noise.add(thermal, gates.CNOT)
noise.add(thermal, gates.Z, (0,1))
circuit = Circuit(3, density_matrix=density_matrix)
circuit.add(gates.CNOT(0,1))
circuit.add(gates.Z(1))
circuit.add(gates.X(1))
circuit.add(gates.X(2))
circuit.add(gates.Z(2))
target_circuit = Circuit(3, density_matrix=density_matrix)
target_circuit.add(gates.CNOT(0,1))
target_circuit.add(gates.ThermalRelaxationChannel(0, 2, 1, 0.3))
target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3))
target_circuit.add(gates.Z(1))
target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3))
target_circuit.add(gates.X(1))
target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3))
target_circuit.add(gates.X(2))
target_circuit.add(gates.Z(2))
initial_psi = random_density_matrix(3) if density_matrix else random_state(3)
np.random.seed(123)
K.set_seed(123)
final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi))
np.random.seed(123)
K.set_seed(123)
target_final_state = target_circuit(initial_state=np.copy(initial_psi))
K.assert_allclose(final_state, target_final_state)
def test_distributed_circuit_addition():
# Attempt to add circuits with different devices
original_backend = qibo.get_backend()
qibo.set_backend("custom")
devices = {"/GPU:0": 2, "/GPU:1": 2}
c1 = models.DistributedCircuit(6, devices)
c2 = models.DistributedCircuit(6, {"/GPU:0": 2})
with pytest.raises(ValueError):
c = c1 + c2
c2 = models.DistributedCircuit(6, devices)
c1.add([gates.H(i) for i in range(6)])
c2.add([gates.CNOT(i, i + 1) for i in range(5)])
c2.add([gates.Z(i) for i in range(6)])
dist_c = c1 + c2
c = models.Circuit(6)
c.add([gates.H(i) for i in range(6)])
c.add([gates.CNOT(i, i + 1) for i in range(5)])
c.add([gates.Z(i) for i in range(6)])
target_state = c().numpy()
final_state = dist_c().numpy()
assert c.depth == dist_c.depth
np.testing.assert_allclose(target_state, final_state)
qibo.set_backend(original_backend)
def test_reset_error(backend, density_matrix):
reset = ResetError(0.8, 0.2)
noise = NoiseModel()
noise.add(reset, gates.X, 1)
noise.add(reset, gates.CNOT)
noise.add(reset, gates.Z, (0,1))
circuit = Circuit(3, density_matrix=density_matrix)
circuit.add(gates.CNOT(0,1))
circuit.add(gates.Z(1))
target_circuit = Circuit(3, density_matrix=density_matrix)
target_circuit.add(gates.CNOT(0,1))
target_circuit.add(gates.ResetChannel(0, 0.8, 0.2))
target_circuit.add(gates.ResetChannel(1, 0.8, 0.2))
target_circuit.add(gates.Z(1))
target_circuit.add(gates.ResetChannel(1, 0.8, 0.2))
initial_psi = random_density_matrix(3) if density_matrix else random_state(3)
np.random.seed(123)
K.set_seed(123)
final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi))
np.random.seed(123)
K.set_seed(123)
target_final_state = target_circuit(initial_state=np.copy(initial_psi))
K.assert_allclose(final_state, target_final_state)
def test_thermal_relaxation_channel_repeated(backend):
initial_state = random_state(5)
c = Circuit(5)
c.add(
gates.ThermalRelaxationChannel(4,
t1=1.0,
t2=0.6,
time=0.8,
excited_population=0.8,
seed=123))
final_state = c(K.cast(np.copy(initial_state)), nshots=30)
pz, p0, p1 = c.queue[0].calculate_probabilities(1.0, 0.6, 0.8, 0.8)
np.random.seed(123)
target_state = []
collapse = gates.M(4, collapse=True)
collapse.nqubits = 5
zgate, xgate = gates.Z(4), gates.X(4)
for _ in range(30):
state = K.cast(np.copy(initial_state))
if np.random.random() < pz:
state = zgate(state)
if np.random.random() < p0:
state = K.state_vector_collapse(collapse, state, [0])
if np.random.random() < p1:
state = K.state_vector_collapse(collapse, state, [0])
state = xgate(state)
target_state.append(K.copy(state))
target_state = K.stack(target_state)
K.assert_allclose(final_state, target_state)
def test_circuit_repeated_execute_with_noise_channel(backend, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
thetas = np.random.random(4)
c = Circuit(4, accelerators)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
if accelerators:
with pytest.raises(NotImplementedError):
c.add((gates.PauliNoiseChannel(
i, px=0.1, py=0.2, pz=0.3, seed=1234) for i in range(4)))
else:
c.add((gates.PauliNoiseChannel(
i, px=0.1, py=0.2, pz=0.3, seed=1234) for i in range(4)))
final_state = c(nshots=20)
np.random.seed(1234)
target_state = []
for _ in range(20):
noiseless_c = Circuit(4)
noiseless_c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
for i in range(4):
if np.random.random() < 0.1:
noiseless_c.add(gates.X(i))
if np.random.random() < 0.2:
noiseless_c.add(gates.Y(i))
if np.random.random() < 0.3:
noiseless_c.add(gates.Z(i))
target_state.append(noiseless_c().numpy())
target_state = np.stack(target_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_measurements_with_probabilistic_noise():
"""Check measurements when simulating noise with repeated execution."""
import tensorflow as tf
thetas = np.random.random(5)
c = models.Circuit(5)
c.add((gates.RX(i, t) for i, t in enumerate(thetas)))
c.add((gates.PauliNoiseChannel(i, px=0.0, py=0.2, pz=0.4, seed=123)
for i in range(5)))
c.add(gates.M(*range(5)))
tf.random.set_seed(123)
result = c(nshots=20)
np.random.seed(123)
tf.random.set_seed(123)
target_samples = []
for _ in range(20):
noiseless_c = models.Circuit(5)
noiseless_c.add((gates.RX(i, t) for i, t in enumerate(thetas)))
for i in range(5):
if np.random.random() < 0.2:
noiseless_c.add(gates.Y(i))
if np.random.random() < 0.4:
noiseless_c.add(gates.Z(i))
noiseless_c.add(gates.M(*range(5)))
target_samples.append(noiseless_c(nshots=1).samples())
target_samples = tf.concat(target_samples, axis=0)
np.testing.assert_allclose(result.samples(), target_samples)
def test_thermal_relaxation_channel_repeated(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = random_state(5)
c = Circuit(5)
c.add(gates.ThermalRelaxationChannel(4, t1=1.0, t2=0.6, time=0.8,
excited_population=0.8, seed=123))
final_state = c(np.copy(initial_state), nshots=30)
pz, p0, p1 = c.queue[0].calculate_probabilities(1.0, 0.6, 0.8, 0.8)
np.random.seed(123)
target_state = []
for _ in range(30):
noiseless_c = Circuit(5)
if np.random.random() < pz:
noiseless_c.add(gates.Z(4))
if np.random.random() < p0:
noiseless_c.add(gates.Collapse(4))
if np.random.random() < p1:
noiseless_c.add(gates.Collapse(4))
noiseless_c.add(gates.X(4))
target_state.append(noiseless_c(np.copy(initial_state)))
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_repeated_execute_pauli_noise_channel(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
thetas = np.random.random(4)
c = Circuit(4)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
c.add((gates.PauliNoiseChannel(i, px=0.1, py=0.2, pz=0.3, seed=1234)
for i in range(4)))
final_state = c(nshots=20)
np.random.seed(1234)
target_state = []
for _ in range(20):
noiseless_c = Circuit(4)
noiseless_c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
for i in range(4):
if np.random.random() < 0.1:
noiseless_c.add(gates.X(i))
if np.random.random() < 0.2:
noiseless_c.add(gates.Y(i))
if np.random.random() < 0.3:
noiseless_c.add(gates.Z(i))
target_state.append(noiseless_c())
target_state = np.stack(target_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_measurements_with_probabilistic_noise(backend):
"""Check measurements when simulating noise with repeated execution."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
thetas = np.random.random(5)
c = models.Circuit(5)
c.add((gates.RX(i, t) for i, t in enumerate(thetas)))
c.add((gates.PauliNoiseChannel(i, px=0.0, py=0.2, pz=0.4, seed=123)
for i in range(5)))
c.add(gates.M(*range(5)))
K.set_seed(123)
samples = c(nshots=20).samples()
np.random.seed(123)
K.set_seed(123)
target_samples = []
for _ in range(20):
noiseless_c = models.Circuit(5)
noiseless_c.add((gates.RX(i, t) for i, t in enumerate(thetas)))
for i in range(5):
if np.random.random() < 0.2:
noiseless_c.add(gates.Y(i))
if np.random.random() < 0.4:
noiseless_c.add(gates.Z(i))
noiseless_c.add(gates.M(*range(5)))
target_samples.append(noiseless_c(nshots=1).samples())
target_samples = np.concatenate(target_samples, axis=0)
np.testing.assert_allclose(samples, target_samples)
qibo.set_backend(original_backend)
def oracle_operator(qubits):
"""Quantum circuit that performs the oracle operator, part of the amplitude estimation algorithm.
Args:
qubits (int): number of qubits used for the unary basis.
Returns:
generator that yield the necessary gates to perform the oracke operator.
"""
yield gates.Z(qubits)
def test_z(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
final_state = apply_gates([gates.H(0), gates.H(1), gates.Z(0)], nqubits=2)
target_state = np.ones_like(final_state) / 2.0
target_state[2] *= -1.0
target_state[3] *= -1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_pauli_error(backend, density_matrix, nshots):
pauli = PauliError(0, 0.2, 0.3)
noise = NoiseModel()
noise.add(pauli, gates.X, 1)
noise.add(pauli, gates.CNOT)
noise.add(pauli, gates.Z, (0,1))
circuit = Circuit(3, density_matrix=density_matrix)
circuit.add(gates.CNOT(0,1))
circuit.add(gates.Z(1))
circuit.add(gates.X(1))
circuit.add(gates.X(2))
circuit.add(gates.Z(2))
circuit.add(gates.M(0, 1, 2))
target_circuit = Circuit(3, density_matrix=density_matrix)
target_circuit.add(gates.CNOT(0,1))
target_circuit.add(gates.PauliNoiseChannel(0, 0, 0.2, 0.3))
target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3))
target_circuit.add(gates.Z(1))
target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3))
target_circuit.add(gates.X(1))
target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3))
target_circuit.add(gates.X(2))
target_circuit.add(gates.Z(2))
target_circuit.add(gates.M(0, 1, 2))
initial_psi = random_density_matrix(3) if density_matrix else random_state(3)
np.random.seed(123)
K.set_seed(123)
final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi), nshots=nshots)
final_state_samples = final_state.samples() if nshots else None
np.random.seed(123)
K.set_seed(123)
target_final_state = target_circuit(initial_state=np.copy(initial_psi), nshots=nshots)
target_final_state_samples = target_final_state.samples() if nshots else None
if nshots is None:
K.assert_allclose(final_state, target_final_state)
else:
K.assert_allclose(final_state_samples, target_final_state_samples)
def test_controlled_execution_large(ndevices):
devices = {"/GPU:0": ndevices // 2, "/GPU:1": ndevices // 2}
dist_c = models.DistributedCircuit(6, devices)
dist_c.add([gates.H(0), gates.H(2), gates.H(3)])
dist_c.add(gates.CNOT(4, 5))
dist_c.add(gates.Z(1).controlled_by(0))
dist_c.add(gates.SWAP(2, 3))
dist_c.add([gates.X(2), gates.X(3), gates.X(4)])
c = models.Circuit(6)
c.add([gates.H(0), gates.H(2), gates.H(3)])
c.add(gates.CNOT(4, 5))
c.add(gates.Z(1).controlled_by(0))
c.add(gates.SWAP(2, 3))
c.add([gates.X(2), gates.X(3), gates.X(4)])
initial_state = utils.random_numpy_state(c.nqubits)
final_state = dist_c(np.copy(initial_state)).numpy()
target_state = c(np.copy(initial_state)).numpy()
np.testing.assert_allclose(target_state, final_state)
def test_distributed_circuit_execution_controlled_by_gates(
backend, accelerators):
dist_c = DistributedCircuit(6, accelerators)
dist_c.add([gates.H(0), gates.H(2), gates.H(3)])
dist_c.add(gates.CNOT(4, 5))
dist_c.add(gates.Z(1).controlled_by(0))
dist_c.add(gates.SWAP(2, 3))
dist_c.add([gates.X(2), gates.X(3), gates.X(4)])
c = Circuit(6)
c.add([gates.H(0), gates.H(2), gates.H(3)])
c.add(gates.CNOT(4, 5))
c.add(gates.Z(1).controlled_by(0))
c.add(gates.SWAP(2, 3))
c.add([gates.X(2), gates.X(3), gates.X(4)])
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_distributed_circuit_execution_addition(backend, accelerators):
# Attempt to add circuits with different devices
c1 = DistributedCircuit(6, {"/GPU:0": 2, "/GPU:1": 2})
c2 = DistributedCircuit(6, {"/GPU:0": 2})
with pytest.raises(ValueError):
c = c1 + c2
c1 = DistributedCircuit(6, accelerators)
c2 = DistributedCircuit(6, accelerators)
c1.add([gates.H(i) for i in range(6)])
c2.add([gates.CNOT(i, i + 1) for i in range(5)])
c2.add([gates.Z(i) for i in range(6)])
dist_c = c1 + c2
c = Circuit(6)
c.add([gates.H(i) for i in range(6)])
c.add([gates.CNOT(i, i + 1) for i in range(5)])
c.add([gates.Z(i) for i in range(6)])
assert c.depth == dist_c.depth
np.testing.assert_allclose(dist_c(), c())
def test_cz(backend, controlled_by):
initial_state = random_state(2)
matrix = np.eye(4)
matrix[3, 3] = -1
target_state = matrix.dot(initial_state)
if controlled_by:
gate = gates.Z(1).controlled_by(0)
else:
gate = gates.CZ(0, 1)
final_state = apply_gates([gate], initial_state=initial_state)
assert gate.name == "cz"
K.assert_allclose(final_state, target_state)
def test_construct_unitary(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
target_matrix = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
np.testing.assert_allclose(gates.H(0).unitary, target_matrix)
target_matrix = np.array([[0, 1], [1, 0]])
np.testing.assert_allclose(gates.X(0).unitary, target_matrix)
target_matrix = np.array([[0, -1j], [1j, 0]])
np.testing.assert_allclose(gates.Y(0).unitary, target_matrix)
target_matrix = np.array([[1, 0], [0, -1]])
np.testing.assert_allclose(gates.Z(1).unitary, target_matrix)
target_matrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1],
[0, 0, 1, 0]])
np.testing.assert_allclose(gates.CNOT(0, 1).unitary, target_matrix)
target_matrix = np.diag([1, 1, 1, -1])
np.testing.assert_allclose(gates.CZ(1, 3).unitary, target_matrix)
target_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0],
[0, 0, 0, 1]])
np.testing.assert_allclose(gates.SWAP(2, 4).unitary, target_matrix)
target_matrix = np.array([[1, 0, 0, 0, 0, 0, 0,
0], [0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0,
0], [0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0,
0], [0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0]])
np.testing.assert_allclose(gates.TOFFOLI(1, 2, 3).unitary, target_matrix)
theta = 0.1234
target_matrix = np.array([[np.cos(theta / 2.0), -1j * np.sin(theta / 2.0)],
[-1j * np.sin(theta / 2.0),
np.cos(theta / 2.0)]])
np.testing.assert_allclose(gates.RX(0, theta).unitary, target_matrix)
target_matrix = np.array([[np.cos(theta / 2.0), -np.sin(theta / 2.0)],
[np.sin(theta / 2.0),
np.cos(theta / 2.0)]])
np.testing.assert_allclose(gates.RY(0, theta).unitary, target_matrix)
target_matrix = np.diag(
[np.exp(-1j * theta / 2.0),
np.exp(1j * theta / 2.0)])
np.testing.assert_allclose(gates.RZ(0, theta).unitary, target_matrix)
target_matrix = np.diag([1, np.exp(1j * theta)])
np.testing.assert_allclose(gates.U1(0, theta).unitary, target_matrix)
target_matrix = np.diag([1, 1, 1, np.exp(1j * theta)])
np.testing.assert_allclose(gates.CU1(0, 1, theta).unitary, target_matrix)
from qibo import matrices
target_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0],
[0, 0, 0, 1]])
np.testing.assert_allclose(matrices.SWAP, target_matrix)
qibo.set_backend(original_backend)
def test_zgate(backend, accelerators):
"""Check Z gate is working properly."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.Z(0))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 2.0
target_state[2] *= -1.0
target_state[3] *= -1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def error_gate(qubit, err, err_type='bitphaseflip'):
"""Gate that implements different types of Pauli errors.
Args:
qubit (int): qubit number where to apply error.
err (float): error probability.
err_type (str): type of error to simulate.
Returns:
generator with error gates if given by probability.
"""
if err != 0:
if err_type == 'bitflip':
if np.random.random() <= err:
yield gates.X(qubit)
elif err_type == 'phaseflip':
if np.random.random() <= err:
yield gates.Z(qubit)
elif err_type == 'bitphaseflip':
if np.random.random() <= err:
yield gates.X(qubit)
if np.random.random() <= err:
yield gates.Z(qubit)
if np.random.random() <= err:
yield gates.Y(qubit)
def test_set_gates_controlled():
devices = {"/GPU:0": 2, "/GPU:1": 2}
c = models.DistributedCircuit(6, devices)
c.add([gates.H(0), gates.H(2), gates.H(3)])
c.add(gates.CNOT(4, 5))
c.add(gates.Z(1).controlled_by(0))
c.add(gates.SWAP(2, 3))
c.add([gates.X(2), gates.X(3), gates.X(4)])
c.queues.set(c.queue)
check_device_queues(c.queues)
assert len(c.queues.queues) == 7
for i, queue in enumerate(c.queues.queues[:-2]):
assert len(queue) == 4 * (1 - i % 2)
for device_group in c.queues.queues[0]:
assert len(device_group) == 7
for device_group in c.queues.queues[2]:
assert len(device_group) == 1
def test_toffoli():
c = Circuit(3)
c.add(gates.Y(0))
c.add(gates.TOFFOLI(0, 1, 2))
c.add(gates.X(1))
c.add(gates.TOFFOLI(0, 2, 1))
c.add(gates.Z(2))
c.add(gates.TOFFOLI(1, 2, 0))
target = f"""// Generated by QIBO {__version__}
OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
y q[0];
ccx q[0],q[1],q[2];
x q[1];
ccx q[0],q[2],q[1];
z q[2];
ccx q[1],q[2],q[0];"""
assert_strings_equal(c.to_qasm(), target)
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_toffoli_cirq():
c1 = Circuit(3)
c1.add(gates.Y(0))
c1.add(gates.TOFFOLI(0, 1, 2))
c1.add(gates.X(1))
c1.add(gates.TOFFOLI(0, 2, 1))
c1.add(gates.Z(2))
c1.add(gates.TOFFOLI(1, 2, 0))
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
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)
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_singlequbit_gates_cirq(backend):
c1 = Circuit(2)
c1.add(gates.H(0))
c1.add(gates.X(1))
c1.add(gates.Y(0))
c1.add(gates.Z(1))
c1.add(gates.S(0))
c1.add(gates.SDG(1))
c1.add(gates.T(0))
c1.add(gates.TDG(1))
c1.add(gates.I(0))
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 # pylint: disable=no-member
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)
def test_circuit_with_noise_probabilistic_channel(backend):
original_backend = qibo.get_backend()
qibo.set_backend(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().numpy())
target_state = np.stack(target_state)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_toffoli_cirq(backend):
import qibo
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(3)
c1.add(gates.Y(0))
c1.add(gates.TOFFOLI(0, 1, 2))
c1.add(gates.X(1))
c1.add(gates.TOFFOLI(0, 2, 1))
c1.add(gates.Z(2))
c1.add(gates.TOFFOLI(1, 2, 0))
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 # pylint: disable=no-member
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_z(backend):
final_state = apply_gates([gates.H(0), gates.H(1), gates.Z(0)], nqubits=2)
target_state = np.ones_like(final_state) / 2.0
target_state[2] *= -1.0
target_state[3] *= -1.0
K.assert_allclose(final_state, target_state)
