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()