def test_distributed_qft_execution(nqubits, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend("custom")
dist_c = models.QFT(nqubits, accelerators=accelerators)
c = models.QFT(nqubits)
initial_state = utils.random_numpy_state(nqubits)
final_state = dist_c(initial_state).numpy()
target_state = c(initial_state).numpy()
np.testing.assert_allclose(target_state, final_state)
qibo.set_backend(original_backend)
def test_qft(backend, accelerators, nqubits):
c = models.QFT(nqubits, accelerators=accelerators)
initial_state = random_state(nqubits)
final_state = c(np.copy(initial_state))
cirq_gates = [(cirq.qft, list(range(nqubits)))]
target_state, _ = execute_cirq(cirq_gates, nqubits, np.copy(initial_state))
K.assert_allclose(target_state, final_state, atol=1e-6)
def test_qft_errors():
"""Check that ``_DistributedQFT`` raises error if not sufficient qubits."""
from qibo.models.circuit import _DistributedQFT
with pytest.raises(NotImplementedError):
c = _DistributedQFT(2, accelerators={"/GPU:0": 4})
with pytest.raises(NotImplementedError):
c = models.QFT(10, with_swaps=False, accelerators={"/GPU:0": 2})
def test_qft_circuit_size(backend, nqubits):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
c = models.QFT(nqubits)
assert c.nqubits == nqubits
assert c.depth == 2 * nqubits
assert c.ngates == nqubits ** 2 // 2 + nqubits
qibo.set_backend(original_backend)
def test_qft_matrix(backend, nqubits):
c = models.QFT(nqubits)
dim = 2**nqubits
target_matrix = qft_matrix(dim)
K.assert_allclose(c.unitary(), target_matrix)
c = c.invert()
target_matrix = qft_matrix(dim, inverse=True)
K.assert_allclose(c.unitary(), target_matrix)
def test_qft_transformation(nqubits):
"""Check QFT transformation for |00...0>."""
c = models.QFT(nqubits)
final_state = c.execute().numpy()
initial_state = np.zeros_like(final_state)
initial_state[0] = 1.0
exact_state = exact_qft(initial_state)
np.testing.assert_allclose(final_state, exact_state, atol=_atol)
def test_qft(backend, nqubits, accelerators):
original_backend = qibo.get_backend()
qibo.set_backend(backend)
initial_state = utils.random_numpy_state(nqubits)
c = models.QFT(nqubits, accelerators=accelerators)
final_state = c(np.copy(initial_state)).numpy()
cirq_gates = [(cirq.QFT, list(range(nqubits)))]
target_state = execute_cirq(cirq_gates, nqubits, np.copy(initial_state))
np.testing.assert_allclose(target_state, final_state, atol=1e-6)
qibo.set_backend(original_backend)
def test_qft_execution(backend, accelerators, nqubits, random):
c = models.QFT(nqubits)
if random:
initial_state = random_state(nqubits)
final_state = c(K.cast(np.copy(initial_state)))
else:
initial_state = c.get_initial_state()
final_state = c()
target_state = exact_qft(K.to_numpy(initial_state))
K.assert_allclose(final_state, target_state)
def CircuitFactory(nqubits, circuit_name, accelerators=None, **kwargs):
if circuit_name == "qft":
circuit = models.QFT(nqubits, accelerators=accelerators)
else:
if circuit_name not in _CIRCUITS:
raise KeyError("Unknown benchmark circuit type {}."
"".format(circuit_name))
circuit = models.Circuit(nqubits, accelerators=accelerators)
circuit.add(_CIRCUITS.get(circuit_name)(nqubits, **kwargs))
return circuit
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 CircuitFactory(nqubits: int,
circuit_type: str,
accelerators: Dict[str, int] = None,
memory_device: str = "/CPU:0",
**kwargs):
if circuit_type == "qft":
circuit = models.QFT(nqubits, accelerators=accelerators,
memory_device=memory_device)
else:
if circuit_type not in _CIRCUITS:
raise TypeError("Unknown benchmark circuit type {}."
"".format(circuit_type))
circuit = models.Circuit(nqubits, accelerators=accelerators,
memory_device=memory_device)
circuit.add(_CIRCUITS[circuit_type](nqubits, **kwargs))
return circuit
def test_distributed_qft_error():
"""Check that ``_DistributedQFT`` raises error if not sufficient qubits."""
with pytest.raises(NotImplementedError):
c = models._DistributedQFT(2, accelerators={"/GPU:0": 4})
with pytest.raises(NotImplementedError):
c = models.QFT(10, with_swaps=False, accelerators={"/GPU:0": 2})
def test_qft_sanity():
"""Check QFT circuit size and depth."""
c = models.QFT(4)
assert c.size == 4
assert c.depth == 8
assert c.ngates == 12
def test_distributed_qft_global_qubits_validity(nqubits, ndevices):
"""Check that no gates are applied to global qubits for practical QFT cases."""
c = models.QFT(nqubits, accelerators={"/GPU:0": ndevices})
c.queues.set(c.queue)
check_device_queues(c.queues)
def test_qft_circuit_size(backend, nqubits):
c = models.QFT(nqubits)
assert c.nqubits == nqubits
assert c.depth == 2 * nqubits
assert c.ngates == nqubits**2 // 2 + nqubits
