def test_circuit_with_noise_with_measurements(backend): """Check ``circuit.with_noise() when using measurement noise.""" original_backend = qibo.get_backend() qibo.set_backend(backend) c = models.Circuit(2, density_matrix=True) c.add([gates.H(0), gates.H(1)]) c.add(gates.M(0)) noisy_c = c.with_noise(3 * (0.1, )) target_c = models.Circuit(2, density_matrix=True) target_c.add(gates.H(0)) target_c.add(gates.PauliNoiseChannel(0, 0.1, 0.1, 0.1)) target_c.add(gates.H(1)) target_c.add(gates.PauliNoiseChannel(1, 0.1, 0.1, 0.1)) final_state = noisy_c().numpy() target_state = target_c().numpy() np.testing.assert_allclose(target_state, final_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_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_u2(backend): """Check U2 gate on random state.""" original_backend = qibo.get_backend() qibo.set_backend(backend) phi = 0.1234 lam = 0.4321 initial_state = utils.random_numpy_state(1) c = Circuit(1) c.add(gates.U2(0, phi, lam)) final_state = c(np.copy(initial_state)) matrix = np.array( [[np.exp(-1j * (phi + lam) / 2), -np.exp(-1j * (phi - lam) / 2)], [np.exp(1j * (phi - lam) / 2), np.exp(1j * (phi + lam) / 2)]]) target_state = matrix.dot(initial_state) / np.sqrt(2) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_vqe(method, options, compile, filename): """Performs a VQE circuit minimization test.""" import qibo original_backend = qibo.get_backend() if method == "sgd" or compile: qibo.set_backend("matmuleinsum") else: qibo.set_backend("custom") nqubits = 6 layers = 4 circuit = Circuit(nqubits) for l in range(layers): for q in range(nqubits): circuit.add(gates.RY(q, theta=1.0)) for q in range(0, nqubits - 1, 2): circuit.add(gates.CZ(q, q + 1)) for q in range(nqubits): circuit.add(gates.RY(q, theta=1.0)) for q in range(1, nqubits - 2, 2): circuit.add(gates.CZ(q, q + 1)) circuit.add(gates.CZ(0, nqubits - 1)) for q in range(nqubits): circuit.add(gates.RY(q, theta=1.0)) hamiltonian = XXZ(nqubits=nqubits) np.random.seed(0) initial_parameters = np.random.uniform(0, 2 * np.pi, 2 * nqubits * layers + nqubits) v = VQE(circuit, hamiltonian) best, params = v.minimize(initial_parameters, method=method, options=options, compile=compile) if method == "cma": # remove `outcmaes` folder import shutil shutil.rmtree("outcmaes") if filename is not None: utils.assert_regression_fixture(params, filename) qibo.set_backend(original_backend)
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_bad_initial_state(backend, accelerators): """Check that errors are raised when bad initial state is passed.""" original_backend = qibo.get_backend() qibo.set_backend(backend) import tensorflow as tf c = Circuit(2, accelerators) c.add([gates.H(0), gates.H(1)]) with pytest.raises(ValueError): final_state = c(initial_state=np.zeros(2**3)) with pytest.raises(ValueError): final_state = c(initial_state=np.zeros((2, 2))) with pytest.raises(ValueError): final_state = c(initial_state=np.zeros((2, 2, 2))) with pytest.raises(TypeError): final_state = c(initial_state=0) c = Circuit(2, accelerators) c.check_initial_state_shape = False with pytest.raises(TypeError): final_state = c(initial_state=0) qibo.set_backend(original_backend)
def test_grover_execute(backend, num_sol): original_backend = qibo.get_backend() qibo.set_backend(backend) def check(result): for i in result: if int(i) != 1: return False return True oracle = Circuit(5 + 1) oracle.add(gates.X(5).controlled_by(*range(5))) grover = Grover(oracle, superposition_qubits=5, check=check, number_solutions=num_sol) solution, iterations = grover(freq=True, logs=True) if num_sol: assert solution == ["11111"] assert iterations == 4 else: assert solution == "11111" qibo.set_backend(original_backend)
def test_density_matrix_measurement(backend): """Check measurement gate on density matrices.""" from qibo.tests_new.test_measurement_gate import assert_result original_backend = qibo.get_backend() qibo.set_backend(backend) state = np.zeros(4) state[2] = 1 rho = np.outer(state, state.conj()) mgate = gates.M(0, 1) mgate.density_matrix = True result = mgate(rho, nshots=100) target_binary_samples = np.zeros((100, 2)) target_binary_samples[:, 0] = 1 assert_result(result, decimal_samples=2 * np.ones((100, )), binary_samples=target_binary_samples, decimal_frequencies={2: 100}, binary_frequencies={"10": 100}) qibo.set_backend(original_backend)
def test_circuit_switch_to_density_matrix(backend): """Test that using `gates.NoiseChnanel` switches vector to density matrix.""" original_backend = qibo.get_backend() qibo.set_backend(backend) c = models.Circuit(2) c.add(gates.H(0)) c.add(gates.H(1)) c.add(gates.NoiseChannel(0, px=0.5)) c.add(gates.NoiseChannel(1, pz=0.3)) final_rho = c().numpy() psi = np.ones(4) / 2 initial_rho = np.outer(psi, psi.conj()) c = models.Circuit(2) c.add(gates.NoiseChannel(0, px=0.5)) c.add(gates.NoiseChannel(1, pz=0.3)) target_rho = c(initial_rho).numpy() np.testing.assert_allclose(final_rho, target_rho) qibo.set_backend(original_backend)
def test_circuit_addition_execution(backend, accelerators): original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(4, accelerators) c1.add(gates.H(0)) c1.add(gates.H(1)) c1.add(gates.H(2)) c2 = Circuit(4, accelerators) c2.add(gates.CNOT(0, 1)) c2.add(gates.CZ(2, 3)) c3 = c1 + c2 c = Circuit(4, accelerators) c.add(gates.H(0)) c.add(gates.H(1)) c.add(gates.H(2)) c.add(gates.CNOT(0, 1)) c.add(gates.CZ(2, 3)) np.testing.assert_allclose(c3(), c()) qibo.set_backend(original_backend)
def test_controlled_by_random(backend, nqubits): """Check controlled_by method on gate.""" original_backend = qibo.get_backend() qibo.set_backend(backend) from qibo.models import Circuit from qibo.tests_new.test_core_gates import random_state initial_psi = random_state(nqubits) initial_rho = np.outer(initial_psi, initial_psi.conj()) c = Circuit(nqubits, density_matrix=True) c.add(gates.RX(1, theta=0.789).controlled_by(2)) c.add(gates.fSim(0, 2, theta=0.123, phi=0.321).controlled_by(1, 3)) final_rho = c(np.copy(initial_rho)) c = Circuit(nqubits) c.add(gates.RX(1, theta=0.789).controlled_by(2)) c.add(gates.fSim(0, 2, theta=0.123, phi=0.321).controlled_by(1, 3)) target_psi = c(np.copy(initial_psi)) target_rho = np.outer(target_psi, np.conj(target_psi)) np.testing.assert_allclose(final_rho, target_rho) qibo.set_backend(original_backend)
def test_from_qasm_measurements(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) target = """OPENQASM 2.0; include "qelib1.inc"; qreg q[5]; creg a[3]; creg b[2]; measure q[0] -> a[0]; x q[3]; measure q[1] -> b[0]; measure q[2] -> a[1]; measure q[4] -> a[2]; measure q[3] -> b[1];""" c = Circuit.from_qasm(target) assert c.depth == 1 assert isinstance(c.queue[0], gates.X) assert isinstance(c.measurement_gate, gates.M) assert c.measurement_tuples == {"a": (0, 2, 4), "b": (1, 3)} qibo.set_backend(original_backend)
def test_set_backend(backend): """Check ``set_backend`` for switching gate backends.""" import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) from qibo import gates if backend == "custom": from qibo.tensorflow import cgates as custom_gates assert isinstance(gates.H(0), custom_gates.TensorflowGate) else: from qibo.tensorflow import gates as native_gates from qibo.tensorflow import einsum einsums = { "defaulteinsum": einsum.DefaultEinsum, "matmuleinsum": einsum.MatmulEinsum } h = gates.H(0) assert isinstance(h, native_gates.TensorflowGate) assert isinstance(h.einsum, einsums[backend]) # pylint: disable=no-member qibo.set_backend(original_backend)
def test_entropy_in_circuit(backend, density_matrix): """Check that entropy calculation works in circuit.""" original_backend = qibo.get_backend() qibo.set_backend(backend) entropy = callbacks.EntanglementEntropy([0], compute_spectrum=True) c = Circuit(2, density_matrix=density_matrix) c.add(gates.CallbackGate(entropy)) c.add(gates.H(0)) c.add(gates.CallbackGate(entropy)) c.add(gates.CNOT(0, 1)) c.add(gates.CallbackGate(entropy)) state = c() target = [0, 0, 1.0] np.testing.assert_allclose(entropy[:], target, atol=_atol) target_spectrum = [0, 0, np.log(2), np.log(2)] entropy_spectrum = np.concatenate(entropy.spectrum).ravel().tolist() np.testing.assert_allclose(entropy_spectrum, target_spectrum, atol=_atol) qibo.set_backend(original_backend)
def test_vector_state_state_deepcopy(deep): """Check if deep copy is really deep.""" # use numpy backend as tensorflow tensors are immutable and cannot # change their value for testing import qibo original_backend = qibo.get_backend() qibo.set_backend("numpy") vector = np.random.random(32) + 1j * np.random.random(32) vector = vector / np.sqrt((np.abs(vector) ** 2).sum()) state = states.VectorState.from_tensor(vector) cstate = state.copy(deep) current_value = state.tensor[0] state.tensor[0] = 0 if deep: K.assert_allclose(state.tensor[0], 0) K.assert_allclose(cstate.tensor[0], current_value) K.assert_allclose(cstate.tensor[1:], state.tensor[1:]) else: K.assert_allclose(cstate.tensor, state.tensor) qibo.set_backend(original_backend)
def test_circuit_invert_and_addition_execution(backend, accelerators): original_backend = qibo.get_backend() qibo.set_backend(backend) subroutine = Circuit(6) subroutine.add([gates.RX(i, theta=0.1) for i in range(5)]) subroutine.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)]) middle = Circuit(6) middle.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)]) circuit = subroutine + middle + subroutine.invert() c = Circuit(6) c.add([gates.RX(i, theta=0.1) for i in range(5)]) c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)]) c.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)]) c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)]) c.add([gates.RX(i, theta=-0.1) for i in range(5)]) assert c.depth == circuit.depth np.testing.assert_allclose(circuit(), c()) qibo.set_backend(original_backend)
def test_controlled_swap(backend, applyx, free_qubit): original_backend = qibo.get_backend() qibo.set_backend(backend) 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() 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_simple_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(2) c1.add(gates.H(0)) c1.add(gates.H(1)) 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()) 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_circuit_with_noise_execution(): """Check ``circuit.with_noise()`` execution.""" original_backend = qibo.get_backend() qibo.set_backend("matmuleinsum") c = models.Circuit(2) c.add([gates.H(0), gates.H(1)]) noisy_c = c.with_noise((0.1, 0.2, 0.3)) target_c = models.Circuit(2) target_c.add(gates.H(0)) target_c.add(gates.NoiseChannel(0, 0.1, 0.2, 0.3)) target_c.add(gates.NoiseChannel(1, 0.1, 0.2, 0.3)) target_c.add(gates.H(1)) target_c.add(gates.NoiseChannel(0, 0.1, 0.2, 0.3)) target_c.add(gates.NoiseChannel(1, 0.1, 0.2, 0.3)) final_state = noisy_c().numpy() target_state = target_c().numpy() np.testing.assert_allclose(target_state, final_state) qibo.set_backend(original_backend)
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_generalizedfsim_dagger(backend, tfmatrix): from scipy.linalg import expm original_backend = qibo.get_backend() qibo.set_backend(backend) phi = 0.2 matrix = np.random.random((2, 2)) matrix = expm(1j * (matrix + matrix.T)) if tfmatrix: import tensorflow as tf from qibo.config import DTYPES matrix = tf.cast(matrix, dtype=DTYPES.get('DTYPECPX')) gate = gates.GeneralizedfSim(0, 1, matrix, phi) c = Circuit(2) c.add((gate, gate.dagger())) initial_state = utils.random_numpy_state(2) final_state = c(np.copy(initial_state)).numpy() np.testing.assert_allclose(final_state, initial_state) qibo.set_backend(original_backend)
def test_collapse_gate(backend, nqubits, targets, results): from qibo import K original_backend = qibo.get_backend() qibo.set_backend(backend) initial_state = random_state(nqubits) collapse = gates.Collapse(*targets, result=results) final_state = apply_gates([collapse], initial_state=np.copy(initial_state)) if isinstance(results, int) or isinstance(results, K.numeric_types): results = nqubits * [results] slicer = nqubits * [slice(None)] for t, r in zip(targets, results): slicer[t] = r slicer = tuple(slicer) initial_state = initial_state.reshape(nqubits * (2, )) target_state = np.zeros_like(initial_state) target_state[slicer] = initial_state[slicer] norm = (np.abs(target_state)**2).sum() target_state = target_state.ravel() / np.sqrt(norm) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_grover_init(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) oracle = Circuit(5 + 1) oracle.add(gates.X(5).controlled_by(*range(5))) superposition = Circuit(5) superposition.add([gates.H(i) for i in range(5)]) grover = Grover(oracle, superposition_circuit=superposition) assert grover.oracle == oracle assert grover.superposition == superposition assert grover.sup_qubits == 5 assert grover.sup_size == 32 assert not grover.iterative grover = Grover(oracle, superposition_circuit=superposition, superposition_size=int(2**5)) assert grover.oracle == oracle assert grover.superposition == superposition assert grover.sup_qubits == 5 assert grover.sup_size == 32 assert not grover.iterative qibo.set_backend(original_backend)
def test_measurement_compiled_circuit(backend): if backend == "custom": # use native gates because custom gates do not support compilation pytest.skip("Custom backend does not support compilation.") original_backend = qibo.get_backend() qibo.set_backend(backend) c = models.Circuit(2) c.add(gates.X(0)) c.add(gates.M(0)) c.add(gates.M(1)) result = c(nshots=100) target_binary_samples = np.zeros((100, 2)) target_binary_samples[:, 0] = 1 assert_result(result, 2 * np.ones((100, )), target_binary_samples, {2: 100}, {"10": 100}) target_state = np.zeros_like(c.final_state) target_state[2] = 1 np.testing.assert_allclose(c.final_state, target_state) qibo.set_backend(original_backend)
def test_circuit_addition_result(backend, accelerators): """Check if circuit addition works properly on Tensorflow circuit.""" original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(2, accelerators) c1.add(gates.H(0)) c1.add(gates.H(1)) c2 = Circuit(2, accelerators) c2.add(gates.CNOT(0, 1)) c3 = c1 + c2 c = Circuit(2, accelerators) c.add(gates.H(0)) c.add(gates.H(1)) c.add(gates.CNOT(0, 1)) np.testing.assert_allclose(c3.execute().numpy(), c.execute().numpy()) qibo.set_backend(original_backend)
def test_final_state(backend, accelerators): """Check that final state is logged correctly when using measurements.""" original_backend = qibo.get_backend() qibo.set_backend(backend) c = models.Circuit(4, accelerators) c.add(gates.X(1)) c.add(gates.X(2)) c.add(gates.M(0, 1)) c.add(gates.M(2)) c.add(gates.X(3)) result = c(nshots=100) c = models.Circuit(4, accelerators) c.add(gates.X(1)) c.add(gates.X(2)) c.add(gates.X(3)) target_state = c() np.testing.assert_allclose(c.final_state, target_state) qibo.set_backend(original_backend)
def test_generalized_fsim(backend, accelerators): """Check GeneralizedfSim gate is working properly on |++>.""" original_backend = qibo.get_backend() qibo.set_backend(backend) phi = np.random.random() rotation = utils.random_numpy_complex((2, 2)) c = Circuit(3, accelerators) c.add((gates.H(i) for i in range(3))) c.add(gates.GeneralizedfSim(1, 2, rotation, phi)) final_state = c.execute().numpy() target_state = np.ones_like(final_state) / np.sqrt(8) matrix = np.eye(4, dtype=target_state.dtype) matrix[1:3, 1:3] = rotation matrix[3, 3] = np.exp(-1j * phi) target_state[:4] = matrix.dot(target_state[:4]) target_state[4:] = matrix.dot(target_state[4:]) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_collapse_after_measurement(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) qubits = [0, 2, 3] c = Circuit(5) c.add((gates.H(i) for i in range(5))) output = c.add(gates.M(*qubits, collapse=True)) c.add((gates.H(i) for i in range(5))) result = c() bitstring = output.samples()[0] final_state = result.state() ct = Circuit(5) for i, r in zip(qubits, bitstring): if r: ct.add(gates.X(i)) ct.add((gates.H(i) for i in qubits)) target_state = ct() np.testing.assert_allclose(final_state, target_state, atol=1e-15) qibo.set_backend(original_backend)