def test_controlled_by_error():
"""Check that using `to_qasm` with controlled by gates raises error."""
c = Circuit(3)
c.add(gates.H(0))
c.add(gates.Y(1).controlled_by(0, 2))
with pytest.raises(ValueError):
c.to_qasm()
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():
"""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_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(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_y(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
final_state = apply_gates([gates.Y(1)], nqubits=2)
target_state = np.zeros_like(final_state)
target_state[1] = 1j
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_parametrized_gate():
c = Circuit(2)
c.add(gates.Y(0))
c.add(gates.RY(1, 0.1234))
target = f"""// Generated by QIBO {__version__}
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
y q[0];
ry(0.1234) q[1];"""
assert_strings_equal(c.to_qasm(), target)
def test_circuit_unitary(backend):
from qibo import matrices
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.CNOT(0, 1))
c.add(gates.X(0))
c.add(gates.Y(1))
h = np.kron(matrices.H, matrices.H)
target_matrix = np.kron(matrices.X, matrices.Y) @ matrices.CNOT @ h
K.assert_allclose(c.unitary(), target_matrix)
def test_ygate(backend):
"""Check Y gate is working properly."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.Y(1))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[1] = 1j
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
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_two_fusion_gate():
"""Check fusion that creates two ``FusedGate``s."""
queue = [gates.X(0), gates.H(1),
gates.RX(2, theta=0.1234).controlled_by(1),
gates.H(2), gates.Y(1),
gates.H(0)]
c = Circuit(3)
c.add(queue)
c = c.fuse()
assert len(c.queue) == 2
fgate1, fgate2 = c.queue
assert fgate2.gates[0] == queue[0]
assert fgate2.gates[1] == queue[-1]
assert fgate1.gates == [queue[1], queue[2], queue[4], queue[3]]
def test_parametrized_gate_cirq():
c1 = Circuit(2)
c1.add(gates.Y(0))
c1.add(gates.RY(1, 0.1234))
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())
final_state_c3 = c3()
np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
def test_measurements():
c = Circuit(2)
c.add(gates.X(0))
c.add(gates.Y(1))
c.add(gates.M(0, 1))
target = f"""// Generated by QIBO {__version__}
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg register0[2];
x q[0];
y q[1];
measure q[0] -> register0[0];
measure q[1] -> register0[1];"""
assert_strings_equal(c.to_qasm(), target)
def test_parametrized_gate_cirq(backend):
import qibo
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(2)
c1.add(gates.Y(0))
c1.add(gates.RY(1, 0.1234))
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())
final_state_c3 = c3()
np.testing.assert_allclose(final_state_c3, final_state_c2, atol=_atol)
qibo.set_backend(original_backend)
def test_from_queue_two_groups():
"""Check fusion that creates two ``FusionGroup``s."""
queue = [
gates.X(0),
gates.H(1),
gates.RX(2, theta=0.1234).controlled_by(1),
gates.H(2),
gates.Y(1),
gates.H(0)
]
fused_groups = fusion.FusionGroup.from_queue(queue)
assert len(fused_groups) == 2
group1, group2 = fused_groups
assert group1.gates0 == [[queue[0], queue[5]]]
assert group1.gates1 == [[queue[1]]]
assert group1.two_qubit_gates == []
assert group2.gates0 == [[], [queue[4]]]
assert group2.gates1 == [[], [queue[3]]]
assert group2.two_qubit_gates == [queue[2]]
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_two_fusion_gate():
"""Check fusion that creates two ``FusedGate``s."""
queue = [
gates.X(0),
gates.H(1),
gates.RX(2, theta=0.1234).controlled_by(1),
gates.H(2),
gates.Y(1),
gates.H(0)
]
c = Circuit(3)
c.add(queue)
c = c.fuse()
assert len(c.queue) == 2
gate1, gate2 = c.queue
if len(gate1.gates) > len(gate2.gates): # pragma: no cover
# disabling coverage as this may not always happen
gate1, gate2 = gate2, gate1
assert gate1.gates == [queue[0], queue[-1]]
assert gate2.gates == queue[1:-1]
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_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 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_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_y(backend):
final_state = apply_gates([gates.Y(1)], nqubits=2)
target_state = np.zeros_like(final_state)
target_state[1] = 1j
K.assert_allclose(final_state, target_state)
