def test_circuit_add_sampling(backend):
"""Check measurements when simulating added circuits with noise"""
# Create random noisy circuit and add noiseless inverted circuit
gates_set = [
gates.X, gates.Y, gates.Z, gates.H, gates.S, gates.SDG, gates.I
]
circ = Circuit(1)
circ_no_noise = Circuit(1)
for _ in range(10):
new_gate = np.random.choice(gates_set)(0)
circ.add(gates.PauliNoiseChannel(0, pz=0.01))
circ.add(new_gate)
circ_no_noise.add(new_gate)
circ.add(gates.PauliNoiseChannel(0, pz=0.01))
circ += circ_no_noise.invert()
circ.add(gates.M(0))
# Sampling using 10 shots
np.random.seed(123)
K.set_seed(123)
samples = circ(nshots=10).samples()
# Sampling using 1 shot in for loop
target_samples = []
K.set_seed(123)
np.random.seed(123)
for _ in range(10):
target_samples.append(circ(nshots=1).samples())
target_samples = np.stack(target_samples)
K.assert_allclose(samples, target_samples[:, 0])
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_noisy_circuit_reexecution(backend):
c = Circuit(2, density_matrix=True)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.PauliNoiseChannel(0, px=0.5))
c.add(gates.PauliNoiseChannel(1, pz=0.3))
final_rho = c().state()
final_rho2 = c().state()
K.assert_allclose(final_rho, final_rho2)
def test_circuit_reexecution(backend):
"""Test re-executing a circuit with `gates.NoiseChnanel`."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2, density_matrix=True)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.PauliNoiseChannel(0, px=0.5))
c.add(gates.PauliNoiseChannel(1, pz=0.3))
final_rho = c().numpy()
final_rho2 = c().numpy()
np.testing.assert_allclose(final_rho, final_rho2)
qibo.set_backend(original_backend)
def test_circuit_with_noise_execution(backend):
c = Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1)])
noisy_c = c.with_noise((0.1, 0.2, 0.3))
final_state = noisy_c()
target_c = Circuit(2, density_matrix=True)
target_c.add(gates.H(0))
target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.2, 0.3))
target_c.add(gates.H(1))
target_c.add(gates.PauliNoiseChannel(1, 0.1, 0.2, 0.3))
target_state = target_c()
K.assert_allclose(final_state, target_state)
def test_circuit_with_noise_measurements(backend):
c = 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, ))
final_state = noisy_c()
target_c = 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))
target_state = target_c()
K.assert_allclose(final_state, target_state)
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_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_noise_channel_repeated(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
thetas = np.random.random(4)
probs = 0.1 * np.random.random([4, 3]) + 0.2
gatelist = [gates.X, gates.Y, gates.Z]
c = Circuit(4)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
c.add((gates.PauliNoiseChannel(i, px, py, pz, seed=123)
for i, (px, py, pz) in enumerate(probs)))
final_state = c(nshots=40)
np.random.seed(123)
target_state = []
for _ in range(40):
noiseless_c = Circuit(4)
noiseless_c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
for i, ps in enumerate(probs):
for p, gate in zip(ps, gatelist):
if np.random.random() < p:
noiseless_c.add(gate(i))
target_state.append(noiseless_c())
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 test_distributed_circuit_add_gate(backend):
# Attempt to add gate so that available global qubits are not enough
c = DistributedCircuit(2, {"/GPU:0": 2})
with pytest.raises(ValueError):
c.add(gates.SWAP(0, 1))
# Attempt adding noise channel
with pytest.raises(NotImplementedError):
c.add(gates.PauliNoiseChannel(0, px=0.1, pz=0.1))
def test_circuit_with_noise_noise_map(backend):
noise_map = {0: (0.1, 0.2, 0.1), 1: (0.2, 0.3, 0.0), 2: (0.0, 0.0, 0.0)}
c = Circuit(3, density_matrix=True)
c.add([gates.H(0), gates.H(1), gates.X(2)])
c.add(gates.M(2))
noisy_c = c.with_noise(noise_map)
final_state = noisy_c()
target_c = Circuit(3, density_matrix=True)
target_c.add(gates.H(0))
target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.2, 0.1))
target_c.add(gates.H(1))
target_c.add(gates.PauliNoiseChannel(1, 0.2, 0.3, 0.0))
target_c.add(gates.X(2))
target_state = target_c()
K.assert_allclose(final_state, target_state)
def test_pauli_noise_channel(backend):
from qibo import matrices
c = Circuit(2, density_matrix=True)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.PauliNoiseChannel(0, px=0.5, pz=0.3))
c.add(gates.PauliNoiseChannel(1, py=0.1, pz=0.3))
final_rho = c().numpy()
psi = np.ones(4) / 2
rho = np.outer(psi, psi.conj())
m1 = np.kron(matrices.X, matrices.I)
m2 = np.kron(matrices.Z, matrices.I)
rho = 0.2 * rho + 0.5 * m1.dot(rho.dot(m1)) + 0.3 * m2.dot(rho.dot(m2))
m1 = np.kron(matrices.I, matrices.Y)
m2 = np.kron(matrices.I, matrices.Z)
rho = 0.6 * rho + 0.1 * m1.dot(rho.dot(m1)) + 0.3 * m2.dot(rho.dot(m2))
K.assert_allclose(final_rho, rho)
def test_circuit_with_noise_execution(backend):
"""Check ``circuit.with_noise()`` execution."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1)])
noisy_c = c.with_noise((0.1, 0.2, 0.3))
target_c = models.Circuit(2, density_matrix=True)
target_c.add(gates.H(0))
target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.2, 0.3))
target_c.add(gates.H(1))
target_c.add(gates.PauliNoiseChannel(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_controlled_by_channel_error():
with pytest.raises(ValueError):
gates.PauliNoiseChannel(0, px=0.5).controlled_by(1)
a1 = np.sqrt(0.4) * np.array([[0, 1], [1, 0]])
a2 = np.sqrt(0.6) * np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1],
[0, 0, 1, 0]])
config = [((1, ), a1), ((0, 1), a2)]
with pytest.raises(ValueError):
gates.KrausChannel(config).controlled_by(1)
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_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_pauli_noise_channel(backend):
initial_rho = random_density_matrix(2)
gate = gates.PauliNoiseChannel(1, px=0.3)
gate.density_matrix = True
final_rho = gate(K.cast(np.copy(initial_rho)))
gate = gates.X(1)
gate.density_matrix = True
initial_rho = K.cast(initial_rho)
target_rho = 0.3 * gate(K.copy(initial_rho))
target_rho += 0.7 * initial_rho
K.assert_allclose(final_rho, target_rho)
def ansatz(p=0):
"""Ansatz for driving a random state into its up-tp-phases canonical form.
Args:
p (float): probability of occuring a single-qubit depolarizing error
Returns:
Qibo circuit implementing the variational ansatz.
"""
C = Circuit(3, density_matrix=p > 0)
for i in range(3):
C.add(gates.RZ(i, theta=0))
C.add(gates.RY(i, theta=0))
C.add(gates.RZ(i, theta=0))
if p > 0:
C.add(gates.PauliNoiseChannel(i, px=p / 3, py=p / 3, pz=p / 3))
for i in range(3):
if p > 0:
C.add(gates.PauliNoiseChannel(i, px=10 * p))
C.add(gates.M(i))
return C
def test_controlled_by_channel():
"""Test that attempting to control channels raises error."""
c = models.Circuit(2, density_matrix=True)
with pytest.raises(ValueError):
c.add(gates.PauliNoiseChannel(0, px=0.5).controlled_by(1))
a1 = np.sqrt(0.4) * np.array([[0, 1], [1, 0]])
a2 = np.sqrt(0.6) * np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1],
[0, 0, 1, 0]])
config = [((1, ), a1), ((0, 1), a2)]
with pytest.raises(ValueError):
gates.KrausChannel(config).controlled_by(1)
def test_multiple_noise(backend):
"""Test `gates.NoiseChnanel` with multiple noise probabilities."""
from qibo import matrices
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.Circuit(2, density_matrix=True)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.PauliNoiseChannel(0, px=0.5, pz=0.3))
c.add(gates.PauliNoiseChannel(1, py=0.1, pz=0.3))
final_rho = c().numpy()
psi = np.ones(4) / 2
rho = np.outer(psi, psi.conj())
m1 = np.kron(matrices.X, matrices.I)
m2 = np.kron(matrices.Z, matrices.I)
rho = 0.2 * rho + 0.5 * m1.dot(rho.dot(m1)) + 0.3 * m2.dot(rho.dot(m2))
m1 = np.kron(matrices.I, matrices.Y)
m2 = np.kron(matrices.I, matrices.Z)
rho = 0.6 * rho + 0.1 * m1.dot(rho.dot(m1)) + 0.3 * m2.dot(rho.dot(m2))
np.testing.assert_allclose(final_rho, rho)
qibo.set_backend(original_backend)
def test_circuit_with_noise_noise_map(backend):
"""Check ``circuit.with_noise() when giving noise map."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
noise_map = {0: (0.1, 0.2, 0.1), 1: (0.2, 0.3, 0.0), 2: (0.0, 0.0, 0.0)}
c = models.Circuit(3, density_matrix=True)
c.add([gates.H(0), gates.H(1), gates.X(2)])
c.add(gates.M(2))
noisy_c = c.with_noise(noise_map)
target_c = models.Circuit(3, density_matrix=True)
target_c.add(gates.H(0))
target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.2, 0.1))
target_c.add(gates.H(1))
target_c.add(gates.PauliNoiseChannel(1, 0.2, 0.3, 0.0))
target_c.add(gates.X(2))
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_with_noise_errors():
c = Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1), gates.PauliNoiseChannel(0, px=0.2)])
with pytest.raises(ValueError):
noisy_c = c.with_noise((0.2, 0.3, 0.0))
c = Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1)])
with pytest.raises(ValueError):
noisy_c = c.with_noise((0.2, 0.3))
with pytest.raises(ValueError):
noisy_c = c.with_noise({0: (0.2, 0.3, 0.1), 1: (0.3, 0.1)})
with pytest.raises(ValueError):
noisy_c = c.with_noise({0: (0.2, 0.3, 0.1)})
with pytest.raises(TypeError):
noisy_c = c.with_noise({0, 1})
def test_bitflip_noise(backend):
"""Test `gates.PauliNoiseChannel` on random initial density matrix."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_rho = utils.random_density_matrix(2)
c = models.Circuit(2, density_matrix=True)
c.add(gates.PauliNoiseChannel(1, px=0.3))
final_rho = c(np.copy(initial_rho)).numpy()
c = models.Circuit(2, density_matrix=True)
c.add(gates.X(1))
target_rho = 0.3 * c(np.copy(initial_rho)).numpy()
target_rho += 0.7 * initial_rho.reshape(target_rho.shape)
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def with_noise(self, noise_map: NoiseMapType) -> "BaseCircuit":
"""Creates a copy of the circuit with noise gates after each gate.
If the original circuit uses state vectors then noise simulation will
be done using sampling and repeated circuit execution.
In order to use density matrices the original circuit should be created
using the ``density_matrix`` flag set to ``True``.
For more information we refer to the
:ref:`How to perform noisy simulation? <noisy-example>` example.
Args:
noise_map (dict): Dictionary that maps qubit ids to noise
probabilities (px, py, pz).
If a tuple of probabilities (px, py, pz) is given instead of
a dictionary, then the same probabilities will be used for all
qubits.
Returns:
Circuit object that contains all the gates of the original circuit
and additional noise channels on all qubits after every gate.
Example:
::
from qibo.models import Circuit
from qibo import gates
# use density matrices for noise simulation
c = Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1), gates.CNOT(0, 1)])
noise_map = {0: (0.1, 0.0, 0.2), 1: (0.0, 0.2, 0.1)}
noisy_c = c.with_noise(noise_map)
# ``noisy_c`` will be equivalent to the following circuit
c2 = Circuit(2, density_matrix=True)
c2.add(gates.H(0))
c2.add(gates.PauliNoiseChannel(0, 0.1, 0.0, 0.2))
c2.add(gates.H(1))
c2.add(gates.PauliNoiseChannel(1, 0.0, 0.2, 0.1))
c2.add(gates.CNOT(0, 1))
c2.add(gates.PauliNoiseChannel(0, 0.1, 0.0, 0.2))
c2.add(gates.PauliNoiseChannel(1, 0.0, 0.2, 0.1))
"""
noise_map = self._check_noise_map(noise_map)
# Generate noise gates
noise_gates = []
for gate in self.queue:
if isinstance(gate, gates.KrausChannel):
raise_error(
ValueError, "`.with_noise` method is not available "
"for circuits that already contain "
"channels.")
noise_gates.append([])
for q in gate.qubits:
if q in noise_map and sum(noise_map[q]) > 0:
p = noise_map[q]
noise_gates[-1].append(
gate_module.PauliNoiseChannel(q,
px=p[0],
py=p[1],
pz=p[2]))
# Create new circuit with noise gates inside
noisy_circuit = self.__class__(self.nqubits)
for i, gate in enumerate(self.queue):
# Do not use `circuit.add` here because these gates are already
# added in the original circuit
noisy_circuit.queue.append(gate)
for noise_gate in noise_gates[i]:
noisy_circuit.add(noise_gate)
noisy_circuit.parametrized_gates = list(self.parametrized_gates)
noisy_circuit.trainable_gates = list(self.trainable_gates)
noisy_circuit.measurement_tuples = dict(self.measurement_tuples)
noisy_circuit.measurement_gate = self.measurement_gate
return noisy_circuit
def test_circuit_with_noise_exception():
"""Check that calling ``with_noise`` in a noisy circuit raises error."""
c = models.Circuit(2, density_matrix=True)
c.add([gates.H(0), gates.H(1), gates.PauliNoiseChannel(0, px=0.2)])
with pytest.raises(ValueError):
noisy_c = c.with_noise((0.2, 0.3, 0.0))
