def test_zpow_gate(backend):
"""Check ZPow and CZPow gate fall back to U1 and CU1 respectively."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(1)
c.add(gates.X(0))
c.add(gates.ZPow(0, theta))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[1] = np.exp(1j * theta)
np.testing.assert_allclose(final_state, target_state)
assert c.queue[1].name == "u1"
c = Circuit(2)
c.add([gates.X(0), gates.X(1)])
c.add(gates.CZPow(0, 1, theta))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[-1] = np.exp(1j * theta)
np.testing.assert_allclose(final_state, target_state)
assert c.queue[2].name == "cu1"
qibo.set_backend(original_backend)
def test_doubly_controlled_by_swap(backend, accelerators):
"""Check controlled SWAP using controlled by two qubits."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4, accelerators)
c.add(gates.X(0))
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().numpy()
c = Circuit(4)
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
target_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
c = Circuit(4, accelerators)
c.add(gates.X(0))
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))
c.add(gates.X(3))
final_state = c.execute().numpy()
c = Circuit(4)
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
c.add(gates.SWAP(1, 2))
target_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_unitary_common_gates(backend):
"""Check that `Unitary` gate can create common gates."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.X(0))
c.add(gates.H(1))
target_state = c.execute().numpy()
c = Circuit(2)
c.add(gates.Unitary(np.array([[0, 1], [1, 0]]), 0))
c.add(gates.Unitary(np.array([[1, 1], [1, -1]]) / np.sqrt(2), 1))
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
thetax = 0.1234
thetay = 0.4321
c = Circuit(2)
c.add(gates.RX(0, theta=thetax))
c.add(gates.RY(1, theta=thetay))
c.add(gates.CNOT(0, 1))
target_state = c.execute().numpy()
c = Circuit(2)
rx = np.array([[np.cos(thetax / 2), -1j * np.sin(thetax / 2)],
[-1j * np.sin(thetax / 2), np.cos(thetax / 2)]])
ry = np.array([[np.cos(thetay / 2), -np.sin(thetay / 2)],
[np.sin(thetay / 2), np.cos(thetay / 2)]])
cnot = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
c.add(gates.Unitary(rx, 0))
c.add(gates.Unitary(ry, 1))
c.add(gates.Unitary(cnot, 0, 1))
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_by_swap(backend):
"""Check controlled SWAP using controlled by for ``nqubits=4``."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4)
c.add(gates.RX(2, theta=0.1234))
c.add(gates.RY(3, theta=0.4321))
c.add(gates.SWAP(2, 3).controlled_by(0))
final_state = c.execute().numpy()
c = Circuit(4)
c.add(gates.RX(2, theta=0.1234))
c.add(gates.RY(3, theta=0.4321))
target_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
c = Circuit(4)
c.add(gates.X(0))
c.add(gates.RX(2, theta=0.1234))
c.add(gates.RY(3, theta=0.4321))
c.add(gates.SWAP(2, 3).controlled_by(0))
c.add(gates.X(0))
final_state = c.execute().numpy()
c = Circuit(4)
c.add(gates.RX(2, theta=0.1234))
c.add(gates.RY(3, theta=0.4321))
c.add(gates.SWAP(2, 3))
target_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_multicontrol_xgate(backend):
"""Check that fallback method for X works for one or two controls."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c1 = Circuit(3)
c1.add(gates.X(0))
c1.add(gates.X(2).controlled_by(0))
final_state = c1.execute().numpy()
c2 = Circuit(3)
c2.add(gates.X(0))
c2.add(gates.CNOT(0, 2))
target_state = c2.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
c1 = Circuit(3)
c1.add(gates.X(0))
c1.add(gates.X(2))
c1.add(gates.X(1).controlled_by(0, 2))
final_state = c1.execute().numpy()
c2 = Circuit(3)
c2.add(gates.X(0))
c2.add(gates.X(2))
c2.add(gates.TOFFOLI(0, 2, 1))
target_state = c2.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_rx(backend, applyx):
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
final_state = c.execute()
c = Circuit(3)
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta))
target_state = c.execute()
K.assert_allclose(final_state, target_state)
def test_controlled_by_fsim(backend, accelerators):
"""Check ``controlled_by`` for fSim gate."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
phi = 0.4321
c = Circuit(6, accelerators)
c.add((gates.H(i) for i in range(6)))
c.add(gates.fSim(5, 3, theta, phi).controlled_by(0, 2, 1))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / np.sqrt(2**6)
rotation = np.array([[np.cos(theta), -1j * np.sin(theta)],
[-1j * np.sin(theta),
np.cos(theta)]])
matrix = np.eye(4, dtype=target_state.dtype)
matrix[1:3, 1:3] = rotation
matrix[3, 3] = np.exp(-1j * phi)
ids = [56, 57, 60, 61]
target_state[ids] = matrix.dot(target_state[ids])
ids = [58, 59, 62, 63]
target_state[ids] = matrix.dot(target_state[ids])
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_identity_gate(backend, accelerators):
"""Check identity gate is working properly."""
qibo.set_backend(backend)
c = Circuit(2, accelerators)
c.add((gates.H(i) for i in range(2)))
c.add(gates.I(0))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 2.0
np.testing.assert_allclose(final_state, target_state)
c = Circuit(4, accelerators)
c.add((gates.H(i) for i in range(4)))
c.add(gates.I(0, 1))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 4.0
np.testing.assert_allclose(final_state, target_state)
def test_controlled_swap(backend, applyx, free_qubit):
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()
K.assert_allclose(final_state, target_state)
def test_multiple_swap(backend):
"""Check SWAP gate is working properly when called multiple times."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(4)
c.add(gates.X(0))
c.add(gates.X(2))
c.add(gates.SWAP(0, 1))
c.add(gates.SWAP(2, 3))
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_controlled_rx(backend, applyx):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
final_state = c.execute()
c = Circuit(3)
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta))
target_state = c.execute()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_swap_double(backend, applyx):
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()
K.assert_allclose(final_state, target_state)
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_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_cnot_no_effect(backend):
"""Check CNOT gate is working properly on |00>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.CNOT(0, 1))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[0] = 1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_unitary(backend, accelerators):
matrix = np.random.random((2, 2))
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.Unitary(matrix, 1).controlled_by(0))
final_state = c.execute()
target_state = np.ones_like(final_state) / 2.0
target_state[2:] = matrix.dot(target_state[2:])
K.assert_allclose(final_state, target_state)
matrix = np.random.random((4, 4))
c = Circuit(4, accelerators)
c.add((gates.H(i) for i in range(4)))
c.add(gates.Unitary(matrix, 1, 3).controlled_by(0, 2))
final_state = c.execute()
target_state = np.ones_like(final_state) / 4.0
ids = [10, 11, 14, 15]
target_state[ids] = matrix.dot(target_state[ids])
K.assert_allclose(final_state, target_state)
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_hadamard(backend):
"""Check Hadamard gate is working properly."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 2
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_xgate(backend, accelerators):
"""Check X gate is working properly."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = Circuit(2, accelerators)
c.add(gates.X(0))
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_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_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_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_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_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 test_rz_phase0(backend):
"""Check RZ gate is working properly when qubit is on |0>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(2)
c.add(gates.RZ(0, theta))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[0] = np.exp(-1j * theta / 2.0)
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_unitary_controlled_by(backend, accelerators):
"""Check that `controlled_by` works as expected with `Unitary`."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
matrix = np.random.random([2, 2])
c = Circuit(2, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.Unitary(matrix, 1).controlled_by(0))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 2.0
target_state[2:] = matrix.dot(target_state[2:])
np.testing.assert_allclose(final_state, target_state)
matrix = np.random.random([4, 4])
c = Circuit(4, accelerators)
c.add((gates.H(i) for i in range(4)))
c.add(gates.Unitary(matrix, 1, 3).controlled_by(0, 2))
final_state = c.execute().numpy()
target_state = np.ones_like(final_state) / 4.0
ids = [10, 11, 14, 15]
target_state[ids] = matrix.dot(target_state[ids])
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_controlled_u1(backend):
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.U1(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
c.add(gates.X(1))
final_state = c.execute()
target_state = np.zeros_like(final_state)
target_state[1] = np.exp(1j * theta)
K.assert_allclose(final_state, target_state)
gate = gates.U1(0, theta).controlled_by(1)
assert gate.__class__.__name__ == "CU1"
def test_zpow(backend):
"""Check ZPow gate is working properly when qubit is on |1>."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(1)
c.add(gates.X(0))
c.add(gates.ZPow(0, theta))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[1] = np.exp(1j * theta )
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_unitary_random_onequbit_gate(backend):
"""Check that ``Unitary`` gate can apply random 2x2 matrices."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
init_state = np.ones(4) / 2.0
matrix = np.random.random([2, 2])
target_state = np.kron(np.eye(2), matrix).dot(init_state)
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.Unitary(matrix, 1, name="random"))
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
def test_doubly_controlled_by_rx_no_effect(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
c.add(gates.RX(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
final_state = c.execute().numpy()
target_state = np.zeros_like(final_state)
target_state[0] = 1.0
np.testing.assert_allclose(final_state, target_state)
qibo.set_backend(original_backend)
