def test_flatten(backend):
target_state = np.ones(4) / 2.0
final_state = apply_gates([gates.Flatten(target_state)], nqubits=2)
K.assert_allclose(final_state, target_state)
target_state = np.ones(4) / 2.0
gate = gates.Flatten(target_state)
with pytest.raises(ValueError):
gate._construct_unitary()
def test_distributed_circuit_execution_special_gate(backend, accelerators):
dist_c = DistributedCircuit(6, accelerators)
initial_state = random_state(dist_c.nqubits)
dist_c.add(gates.Flatten(np.copy(initial_state)))
dist_c.add((gates.H(i) for i in range(dist_c.nlocal)))
dist_c.global_qubits = range(dist_c.nlocal, dist_c.nqubits)
c = Circuit(6)
c.add(gates.Flatten(np.copy(initial_state)))
c.add((gates.H(i) for i in range(dist_c.nlocal)))
np.testing.assert_allclose(dist_c(), c())
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_flatten(backend):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
target_state = np.ones(4) / 2.0
final_state = apply_gates([gates.Flatten(target_state)], nqubits=2)
np.testing.assert_allclose(final_state, target_state)
target_state = np.ones(4) / 2.0
gate = gates.Flatten(target_state)
with pytest.raises(ValueError):
gate.construct_unitary()
qibo.set_backend(original_backend)
def test_unbalanced_probabilistic_measurement(backend, use_samples):
original_backend = qibo.get_backend()
original_threads = qibo.get_threads()
qibo.set_backend(backend)
# set single-thread to fix the random values generated from the frequency custom op
qibo.set_threads(1)
state = np.array([1, 1, 1, np.sqrt(3)]) / np.sqrt(6)
c = models.Circuit(2)
c.add(gates.Flatten(state))
c.add(gates.M(0, 1))
result = c(nshots=1000)
K.set_seed(1234)
if use_samples:
# calculates sample tensor directly using `tf.random.categorical`
# otherwise it uses the frequency-only calculation
_ = result.samples()
# update reference values based on backend and device
if K.name == "tensorflow":
if K.gpu_devices: # pragma: no cover
# CI does not use GPU
decimal_frequencies = {0: 196, 1: 153, 2: 156, 3: 495}
else:
decimal_frequencies = {0: 168, 1: 188, 2: 154, 3: 490}
elif K.name == "numpy":
decimal_frequencies = {0: 171, 1: 148, 2: 161, 3: 520}
assert sum(result.frequencies().values()) == 1000
assert_result(result, decimal_frequencies=decimal_frequencies)
qibo.set_backend(original_backend)
qibo.set_threads(original_threads)
def test_flatten_density_matrix(backend):
"""Check ``Flatten`` gate works with density matrices."""
target_rho = random_density_matrix(3)
initial_rho = np.zeros(6 * (2,))
gate = gates.Flatten(target_rho)
gate.density_matrix = True
final_rho = np.reshape(gate(initial_rho), (8, 8))
K.assert_allclose(final_rho, target_rho)
def test_fusion_errors():
group = fusion.FusionGroup()
with pytest.raises(ValueError):
group.first_gate(2)
group = fusion.FusionGroup()
group.add(gates.Flatten(np.ones(4)))
group.can_add(gates.H(0))
with pytest.raises(RuntimeError):
group.add(gates.H(0))
group = fusion.FusionGroup()
group.can_add(gates.H(0))
group.add(gates.H(0))
group.can_add(gates.RX(0, theta=0.1234).controlled_by(1))
with pytest.raises(ValueError):
group.add(gates.Flatten(np.ones(4)))
group = fusion.FusionGroup()
group.add(gates.RX(0, theta=0.1234).controlled_by(1))
with pytest.raises(ValueError):
group.add(gates.H(2))
group = fusion.FusionGroup()
group.add(gates.RX(0, theta=0.1234).controlled_by(1))
with pytest.raises(ValueError):
group.add(gates.CZ(1, 2))
group = fusion.FusionGroup()
with pytest.raises(ValueError):
group.add(gates.TOFFOLI(0, 1, 2))
group = fusion.FusionGroup()
with pytest.raises(RuntimeError):
group.calculate()
# Fuse distributed circuit after gates are set
import qibo
if qibo.get_backend() == "custom":
c = Circuit(4, accelerators={"/GPU:0": 2})
c.add((gates.H(i) for i in range(4)))
final_state = c()
with pytest.raises(RuntimeError):
fused_c = c.fuse()
def test_execution_special_gate(ndevices):
original_backend = qibo.get_backend()
qibo.set_backend("custom")
devices = {"/GPU:0": ndevices // 2, "/GPU:1": ndevices // 2}
dist_c = models.DistributedCircuit(6, devices)
initial_state = utils.random_numpy_state(dist_c.nqubits)
dist_c.add(gates.Flatten(np.copy(initial_state)))
dist_c.add((gates.H(i) for i in range(dist_c.nlocal)))
dist_c.global_qubits = range(dist_c.nlocal, dist_c.nqubits)
c = models.Circuit(6)
c.add(gates.Flatten(np.copy(initial_state)))
c.add((gates.H(i) for i in range(dist_c.nlocal)))
final_state = dist_c().numpy()
target_state = c().numpy()
np.testing.assert_allclose(target_state, final_state)
qibo.set_backend(original_backend)
def test_flatten_density_matrix():
"""Check ``Flatten`` gate works with density matrices."""
original_backend = qibo.get_backend()
qibo.set_backend("matmuleinsum")
target_rho = random_density_matrix(3)
initial_rho = np.zeros(6 * (2,))
gate = gates.Flatten(target_rho)
final_rho = gate(initial_rho, is_density_matrix=True).numpy().reshape((8, 8))
np.testing.assert_allclose(final_rho, target_rho)
qibo.set_backend(original_backend)
def test_qft_transformation_random(nqubits):
"""Check QFT transformation for random initial state."""
initial_state = utils.random_numpy_state(nqubits)
exact_state = exact_qft(initial_state)
c_init = models.Circuit(nqubits)
c_init.add(gates.Flatten(initial_state))
c = c_init + models.QFT(nqubits)
final_state = c.execute().numpy()
np.testing.assert_allclose(final_state, exact_state, atol=_atol)
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_unbalanced_probabilistic_measurement(backend, use_samples):
original_threads = qibo.get_threads()
# set single-thread to fix the random values generated from the frequency custom op
qibo.set_threads(1)
state = np.array([1, 1, 1, np.sqrt(3)]) / np.sqrt(6)
c = models.Circuit(2)
c.add(gates.Flatten(state))
c.add(gates.M(0, 1))
result = c(nshots=1000)
K.set_seed(1234)
if use_samples:
# calculates sample tensor directly using `tf.random.categorical`
# otherwise it uses the frequency-only calculation
_ = result.samples()
# update reference values based on backend and device
decimal_frequencies = K.test_regressions(
"test_unbalanced_probabilistic_measurement")
assert sum(result.frequencies().values()) == 1000
assert_result(result, decimal_frequencies=decimal_frequencies)
qibo.set_threads(original_threads)
def test_unbalanced_probabilistic_measurement():
import tensorflow as tf
tf.random.set_seed(1234)
state = np.array([1, 1, 1, np.sqrt(3)]) / 2.0
c = models.Circuit(2)
c.add(gates.Flatten(state))
c.add(gates.M(0, 1))
result = c(nshots=1000)
# update reference values based on device
if tf.config.list_physical_devices("GPU"): # pragma: no cover
# case not tested in GitHub workflows because it requires GPU
decimal_freqs = {0: 196, 1: 153, 2: 156, 3: 495}
binary_freqs = {"00": 196, "01": 153, "10": 156, "11": 495}
else:
decimal_freqs = {0: 168, 1: 188, 2: 154, 3: 490}
binary_freqs = {"00": 168, "01": 188, "10": 154, "11": 490}
assert sum(binary_freqs.values()) == 1000
assert_results(result,
decimal_frequencies=decimal_freqs,
binary_frequencies=binary_freqs)
def test_unknown_gate_error():
""""Check that using `to_qasm` with not supported gates raises error."""
c = Circuit(2)
c.add(gates.Flatten(4 * [0]))
with pytest.raises(ValueError):
c.to_qasm()
