def test_thermal_error(backend, density_matrix): thermal = ThermalRelaxationError(2, 1, 0.3) noise = NoiseModel() noise.add(thermal, gates.X, 1) noise.add(thermal, gates.CNOT) noise.add(thermal, gates.Z, (0,1)) circuit = Circuit(3, density_matrix=density_matrix) circuit.add(gates.CNOT(0,1)) circuit.add(gates.Z(1)) circuit.add(gates.X(1)) circuit.add(gates.X(2)) circuit.add(gates.Z(2)) target_circuit = Circuit(3, density_matrix=density_matrix) target_circuit.add(gates.CNOT(0,1)) target_circuit.add(gates.ThermalRelaxationChannel(0, 2, 1, 0.3)) target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3)) target_circuit.add(gates.Z(1)) target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3)) target_circuit.add(gates.X(1)) target_circuit.add(gates.ThermalRelaxationChannel(1, 2, 1, 0.3)) target_circuit.add(gates.X(2)) target_circuit.add(gates.Z(2)) initial_psi = random_density_matrix(3) if density_matrix else random_state(3) np.random.seed(123) K.set_seed(123) final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi)) np.random.seed(123) K.set_seed(123) target_final_state = target_circuit(initial_state=np.copy(initial_psi)) K.assert_allclose(final_state, target_final_state)
def test_distributed_circuit_addition(): # Attempt to add circuits with different devices original_backend = qibo.get_backend() qibo.set_backend("custom") devices = {"/GPU:0": 2, "/GPU:1": 2} c1 = models.DistributedCircuit(6, devices) c2 = models.DistributedCircuit(6, {"/GPU:0": 2}) with pytest.raises(ValueError): c = c1 + c2 c2 = models.DistributedCircuit(6, devices) c1.add([gates.H(i) for i in range(6)]) c2.add([gates.CNOT(i, i + 1) for i in range(5)]) c2.add([gates.Z(i) for i in range(6)]) dist_c = c1 + c2 c = models.Circuit(6) c.add([gates.H(i) for i in range(6)]) c.add([gates.CNOT(i, i + 1) for i in range(5)]) c.add([gates.Z(i) for i in range(6)]) target_state = c().numpy() final_state = dist_c().numpy() assert c.depth == dist_c.depth np.testing.assert_allclose(target_state, final_state) qibo.set_backend(original_backend)
def test_reset_error(backend, density_matrix): reset = ResetError(0.8, 0.2) noise = NoiseModel() noise.add(reset, gates.X, 1) noise.add(reset, gates.CNOT) noise.add(reset, gates.Z, (0,1)) circuit = Circuit(3, density_matrix=density_matrix) circuit.add(gates.CNOT(0,1)) circuit.add(gates.Z(1)) target_circuit = Circuit(3, density_matrix=density_matrix) target_circuit.add(gates.CNOT(0,1)) target_circuit.add(gates.ResetChannel(0, 0.8, 0.2)) target_circuit.add(gates.ResetChannel(1, 0.8, 0.2)) target_circuit.add(gates.Z(1)) target_circuit.add(gates.ResetChannel(1, 0.8, 0.2)) initial_psi = random_density_matrix(3) if density_matrix else random_state(3) np.random.seed(123) K.set_seed(123) final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi)) np.random.seed(123) K.set_seed(123) target_final_state = target_circuit(initial_state=np.copy(initial_psi)) K.assert_allclose(final_state, target_final_state)
def test_thermal_relaxation_channel_repeated(backend): initial_state = random_state(5) c = Circuit(5) c.add( gates.ThermalRelaxationChannel(4, t1=1.0, t2=0.6, time=0.8, excited_population=0.8, seed=123)) final_state = c(K.cast(np.copy(initial_state)), nshots=30) pz, p0, p1 = c.queue[0].calculate_probabilities(1.0, 0.6, 0.8, 0.8) np.random.seed(123) target_state = [] collapse = gates.M(4, collapse=True) collapse.nqubits = 5 zgate, xgate = gates.Z(4), gates.X(4) for _ in range(30): state = K.cast(np.copy(initial_state)) if np.random.random() < pz: state = zgate(state) if np.random.random() < p0: state = K.state_vector_collapse(collapse, state, [0]) if np.random.random() < p1: state = K.state_vector_collapse(collapse, state, [0]) state = xgate(state) target_state.append(K.copy(state)) target_state = K.stack(target_state) K.assert_allclose(final_state, target_state)
def test_circuit_repeated_execute_with_noise_channel(backend, accelerators): original_backend = qibo.get_backend() qibo.set_backend(backend) thetas = np.random.random(4) c = Circuit(4, accelerators) c.add((gates.RY(i, t) for i, t in enumerate(thetas))) if accelerators: with pytest.raises(NotImplementedError): c.add((gates.PauliNoiseChannel( i, px=0.1, py=0.2, pz=0.3, seed=1234) for i in range(4))) else: c.add((gates.PauliNoiseChannel( i, px=0.1, py=0.2, pz=0.3, seed=1234) for i in range(4))) final_state = c(nshots=20) np.random.seed(1234) target_state = [] for _ in range(20): noiseless_c = Circuit(4) noiseless_c.add((gates.RY(i, t) for i, t in enumerate(thetas))) for i in range(4): if np.random.random() < 0.1: noiseless_c.add(gates.X(i)) if np.random.random() < 0.2: noiseless_c.add(gates.Y(i)) if np.random.random() < 0.3: noiseless_c.add(gates.Z(i)) target_state.append(noiseless_c().numpy()) target_state = np.stack(target_state) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_measurements_with_probabilistic_noise(): """Check measurements when simulating noise with repeated execution.""" import tensorflow as tf thetas = np.random.random(5) c = models.Circuit(5) c.add((gates.RX(i, t) for i, t in enumerate(thetas))) c.add((gates.PauliNoiseChannel(i, px=0.0, py=0.2, pz=0.4, seed=123) for i in range(5))) c.add(gates.M(*range(5))) tf.random.set_seed(123) result = c(nshots=20) np.random.seed(123) tf.random.set_seed(123) target_samples = [] for _ in range(20): noiseless_c = models.Circuit(5) noiseless_c.add((gates.RX(i, t) for i, t in enumerate(thetas))) for i in range(5): if np.random.random() < 0.2: noiseless_c.add(gates.Y(i)) if np.random.random() < 0.4: noiseless_c.add(gates.Z(i)) noiseless_c.add(gates.M(*range(5))) target_samples.append(noiseless_c(nshots=1).samples()) target_samples = tf.concat(target_samples, axis=0) np.testing.assert_allclose(result.samples(), target_samples)
def test_thermal_relaxation_channel_repeated(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) initial_state = random_state(5) c = Circuit(5) c.add(gates.ThermalRelaxationChannel(4, t1=1.0, t2=0.6, time=0.8, excited_population=0.8, seed=123)) final_state = c(np.copy(initial_state), nshots=30) pz, p0, p1 = c.queue[0].calculate_probabilities(1.0, 0.6, 0.8, 0.8) np.random.seed(123) target_state = [] for _ in range(30): noiseless_c = Circuit(5) if np.random.random() < pz: noiseless_c.add(gates.Z(4)) if np.random.random() < p0: noiseless_c.add(gates.Collapse(4)) if np.random.random() < p1: noiseless_c.add(gates.Collapse(4)) noiseless_c.add(gates.X(4)) target_state.append(noiseless_c(np.copy(initial_state))) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_repeated_execute_pauli_noise_channel(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) thetas = np.random.random(4) c = Circuit(4) c.add((gates.RY(i, t) for i, t in enumerate(thetas))) c.add((gates.PauliNoiseChannel(i, px=0.1, py=0.2, pz=0.3, seed=1234) for i in range(4))) final_state = c(nshots=20) np.random.seed(1234) target_state = [] for _ in range(20): noiseless_c = Circuit(4) noiseless_c.add((gates.RY(i, t) for i, t in enumerate(thetas))) for i in range(4): if np.random.random() < 0.1: noiseless_c.add(gates.X(i)) if np.random.random() < 0.2: noiseless_c.add(gates.Y(i)) if np.random.random() < 0.3: noiseless_c.add(gates.Z(i)) target_state.append(noiseless_c()) target_state = np.stack(target_state) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_measurements_with_probabilistic_noise(backend): """Check measurements when simulating noise with repeated execution.""" original_backend = qibo.get_backend() qibo.set_backend(backend) thetas = np.random.random(5) c = models.Circuit(5) c.add((gates.RX(i, t) for i, t in enumerate(thetas))) c.add((gates.PauliNoiseChannel(i, px=0.0, py=0.2, pz=0.4, seed=123) for i in range(5))) c.add(gates.M(*range(5))) K.set_seed(123) samples = c(nshots=20).samples() np.random.seed(123) K.set_seed(123) target_samples = [] for _ in range(20): noiseless_c = models.Circuit(5) noiseless_c.add((gates.RX(i, t) for i, t in enumerate(thetas))) for i in range(5): if np.random.random() < 0.2: noiseless_c.add(gates.Y(i)) if np.random.random() < 0.4: noiseless_c.add(gates.Z(i)) noiseless_c.add(gates.M(*range(5))) target_samples.append(noiseless_c(nshots=1).samples()) target_samples = np.concatenate(target_samples, axis=0) np.testing.assert_allclose(samples, target_samples) qibo.set_backend(original_backend)
def oracle_operator(qubits): """Quantum circuit that performs the oracle operator, part of the amplitude estimation algorithm. Args: qubits (int): number of qubits used for the unary basis. Returns: generator that yield the necessary gates to perform the oracke operator. """ yield gates.Z(qubits)
def test_z(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) final_state = apply_gates([gates.H(0), gates.H(1), gates.Z(0)], nqubits=2) 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_pauli_error(backend, density_matrix, nshots): pauli = PauliError(0, 0.2, 0.3) noise = NoiseModel() noise.add(pauli, gates.X, 1) noise.add(pauli, gates.CNOT) noise.add(pauli, gates.Z, (0,1)) circuit = Circuit(3, density_matrix=density_matrix) circuit.add(gates.CNOT(0,1)) circuit.add(gates.Z(1)) circuit.add(gates.X(1)) circuit.add(gates.X(2)) circuit.add(gates.Z(2)) circuit.add(gates.M(0, 1, 2)) target_circuit = Circuit(3, density_matrix=density_matrix) target_circuit.add(gates.CNOT(0,1)) target_circuit.add(gates.PauliNoiseChannel(0, 0, 0.2, 0.3)) target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3)) target_circuit.add(gates.Z(1)) target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3)) target_circuit.add(gates.X(1)) target_circuit.add(gates.PauliNoiseChannel(1, 0, 0.2, 0.3)) target_circuit.add(gates.X(2)) target_circuit.add(gates.Z(2)) target_circuit.add(gates.M(0, 1, 2)) initial_psi = random_density_matrix(3) if density_matrix else random_state(3) np.random.seed(123) K.set_seed(123) final_state = noise.apply(circuit)(initial_state=np.copy(initial_psi), nshots=nshots) final_state_samples = final_state.samples() if nshots else None np.random.seed(123) K.set_seed(123) target_final_state = target_circuit(initial_state=np.copy(initial_psi), nshots=nshots) target_final_state_samples = target_final_state.samples() if nshots else None if nshots is None: K.assert_allclose(final_state, target_final_state) else: K.assert_allclose(final_state_samples, target_final_state_samples)
def test_controlled_execution_large(ndevices): devices = {"/GPU:0": ndevices // 2, "/GPU:1": ndevices // 2} dist_c = models.DistributedCircuit(6, devices) dist_c.add([gates.H(0), gates.H(2), gates.H(3)]) dist_c.add(gates.CNOT(4, 5)) dist_c.add(gates.Z(1).controlled_by(0)) dist_c.add(gates.SWAP(2, 3)) dist_c.add([gates.X(2), gates.X(3), gates.X(4)]) c = models.Circuit(6) c.add([gates.H(0), gates.H(2), gates.H(3)]) c.add(gates.CNOT(4, 5)) c.add(gates.Z(1).controlled_by(0)) c.add(gates.SWAP(2, 3)) c.add([gates.X(2), gates.X(3), gates.X(4)]) initial_state = utils.random_numpy_state(c.nqubits) final_state = dist_c(np.copy(initial_state)).numpy() target_state = c(np.copy(initial_state)).numpy() np.testing.assert_allclose(target_state, final_state)
def test_distributed_circuit_execution_controlled_by_gates( backend, accelerators): dist_c = DistributedCircuit(6, accelerators) dist_c.add([gates.H(0), gates.H(2), gates.H(3)]) dist_c.add(gates.CNOT(4, 5)) dist_c.add(gates.Z(1).controlled_by(0)) dist_c.add(gates.SWAP(2, 3)) dist_c.add([gates.X(2), gates.X(3), gates.X(4)]) c = Circuit(6) c.add([gates.H(0), gates.H(2), gates.H(3)]) c.add(gates.CNOT(4, 5)) c.add(gates.Z(1).controlled_by(0)) c.add(gates.SWAP(2, 3)) c.add([gates.X(2), gates.X(3), gates.X(4)]) initial_state = random_state(c.nqubits) final_state = dist_c(np.copy(initial_state)) target_state = c(np.copy(initial_state)) np.testing.assert_allclose(target_state, final_state)
def test_distributed_circuit_execution_addition(backend, accelerators): # Attempt to add circuits with different devices c1 = DistributedCircuit(6, {"/GPU:0": 2, "/GPU:1": 2}) c2 = DistributedCircuit(6, {"/GPU:0": 2}) with pytest.raises(ValueError): c = c1 + c2 c1 = DistributedCircuit(6, accelerators) c2 = DistributedCircuit(6, accelerators) c1.add([gates.H(i) for i in range(6)]) c2.add([gates.CNOT(i, i + 1) for i in range(5)]) c2.add([gates.Z(i) for i in range(6)]) dist_c = c1 + c2 c = Circuit(6) c.add([gates.H(i) for i in range(6)]) c.add([gates.CNOT(i, i + 1) for i in range(5)]) c.add([gates.Z(i) for i in range(6)]) assert c.depth == dist_c.depth np.testing.assert_allclose(dist_c(), c())
def test_cz(backend, controlled_by): initial_state = random_state(2) matrix = np.eye(4) matrix[3, 3] = -1 target_state = matrix.dot(initial_state) if controlled_by: gate = gates.Z(1).controlled_by(0) else: gate = gates.CZ(0, 1) final_state = apply_gates([gate], initial_state=initial_state) assert gate.name == "cz" K.assert_allclose(final_state, target_state)
def test_construct_unitary(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) target_matrix = np.array([[1, 1], [1, -1]]) / np.sqrt(2) np.testing.assert_allclose(gates.H(0).unitary, target_matrix) target_matrix = np.array([[0, 1], [1, 0]]) np.testing.assert_allclose(gates.X(0).unitary, target_matrix) target_matrix = np.array([[0, -1j], [1j, 0]]) np.testing.assert_allclose(gates.Y(0).unitary, target_matrix) target_matrix = np.array([[1, 0], [0, -1]]) np.testing.assert_allclose(gates.Z(1).unitary, target_matrix) target_matrix = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]) np.testing.assert_allclose(gates.CNOT(0, 1).unitary, target_matrix) target_matrix = np.diag([1, 1, 1, -1]) np.testing.assert_allclose(gates.CZ(1, 3).unitary, target_matrix) target_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]) np.testing.assert_allclose(gates.SWAP(2, 4).unitary, target_matrix) target_matrix = np.array([[1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0]]) np.testing.assert_allclose(gates.TOFFOLI(1, 2, 3).unitary, target_matrix) theta = 0.1234 target_matrix = np.array([[np.cos(theta / 2.0), -1j * np.sin(theta / 2.0)], [-1j * np.sin(theta / 2.0), np.cos(theta / 2.0)]]) np.testing.assert_allclose(gates.RX(0, theta).unitary, target_matrix) target_matrix = np.array([[np.cos(theta / 2.0), -np.sin(theta / 2.0)], [np.sin(theta / 2.0), np.cos(theta / 2.0)]]) np.testing.assert_allclose(gates.RY(0, theta).unitary, target_matrix) target_matrix = np.diag( [np.exp(-1j * theta / 2.0), np.exp(1j * theta / 2.0)]) np.testing.assert_allclose(gates.RZ(0, theta).unitary, target_matrix) target_matrix = np.diag([1, np.exp(1j * theta)]) np.testing.assert_allclose(gates.U1(0, theta).unitary, target_matrix) target_matrix = np.diag([1, 1, 1, np.exp(1j * theta)]) np.testing.assert_allclose(gates.CU1(0, 1, theta).unitary, target_matrix) from qibo import matrices target_matrix = np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]) np.testing.assert_allclose(matrices.SWAP, target_matrix) 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 error_gate(qubit, err, err_type='bitphaseflip'): """Gate that implements different types of Pauli errors. Args: qubit (int): qubit number where to apply error. err (float): error probability. err_type (str): type of error to simulate. Returns: generator with error gates if given by probability. """ if err != 0: if err_type == 'bitflip': if np.random.random() <= err: yield gates.X(qubit) elif err_type == 'phaseflip': if np.random.random() <= err: yield gates.Z(qubit) elif err_type == 'bitphaseflip': if np.random.random() <= err: yield gates.X(qubit) if np.random.random() <= err: yield gates.Z(qubit) if np.random.random() <= err: yield gates.Y(qubit)
def test_set_gates_controlled(): devices = {"/GPU:0": 2, "/GPU:1": 2} c = models.DistributedCircuit(6, devices) c.add([gates.H(0), gates.H(2), gates.H(3)]) c.add(gates.CNOT(4, 5)) c.add(gates.Z(1).controlled_by(0)) c.add(gates.SWAP(2, 3)) c.add([gates.X(2), gates.X(3), gates.X(4)]) c.queues.set(c.queue) check_device_queues(c.queues) assert len(c.queues.queues) == 7 for i, queue in enumerate(c.queues.queues[:-2]): assert len(queue) == 4 * (1 - i % 2) for device_group in c.queues.queues[0]: assert len(device_group) == 7 for device_group in c.queues.queues[2]: assert len(device_group) == 1
def test_toffoli(): c = Circuit(3) c.add(gates.Y(0)) c.add(gates.TOFFOLI(0, 1, 2)) c.add(gates.X(1)) c.add(gates.TOFFOLI(0, 2, 1)) c.add(gates.Z(2)) c.add(gates.TOFFOLI(1, 2, 0)) target = f"""// Generated by QIBO {__version__} OPENQASM 2.0; include "qelib1.inc"; qreg q[3]; y q[0]; ccx q[0],q[1],q[2]; x q[1]; ccx q[0],q[2],q[1]; z q[2]; ccx q[1],q[2],q[0];""" assert_strings_equal(c.to_qasm(), target)
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_toffoli_cirq(): c1 = Circuit(3) c1.add(gates.Y(0)) c1.add(gates.TOFFOLI(0, 1, 2)) c1.add(gates.X(1)) c1.add(gates.TOFFOLI(0, 2, 1)) c1.add(gates.Z(2)) c1.add(gates.TOFFOLI(1, 2, 0)) 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 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)
def test_repeated_execute_with_noise(backend): thetas = np.random.random(4) c = Circuit(4) c.add((gates.RY(i, t) for i, t in enumerate(thetas))) noisy_c = c.with_noise((0.2, 0.0, 0.1)) np.random.seed(1234) final_state = noisy_c(nshots=20) np.random.seed(1234) target_state = [] for _ in range(20): noiseless_c = Circuit(4) for i, t in enumerate(thetas): noiseless_c.add(gates.RY(i, theta=t)) if np.random.random() < 0.2: noiseless_c.add(gates.X(i)) if np.random.random() < 0.1: noiseless_c.add(gates.Z(i)) target_state.append(noiseless_c()) target_state = np.stack(target_state) K.assert_allclose(final_state, target_state)
def test_singlequbit_gates_cirq(backend): c1 = Circuit(2) c1.add(gates.H(0)) c1.add(gates.X(1)) c1.add(gates.Y(0)) c1.add(gates.Z(1)) c1.add(gates.S(0)) c1.add(gates.SDG(1)) c1.add(gates.T(0)) c1.add(gates.TDG(1)) c1.add(gates.I(0)) 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 # pylint: disable=no-member 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)
def test_circuit_with_noise_probabilistic_channel(backend): original_backend = qibo.get_backend() qibo.set_backend(backend) thetas = np.random.random(4) c = Circuit(4) c.add((gates.RY(i, t) for i, t in enumerate(thetas))) noisy_c = c.with_noise((0.2, 0.0, 0.1)) np.random.seed(1234) final_state = noisy_c(nshots=20) np.random.seed(1234) target_state = [] for _ in range(20): noiseless_c = Circuit(4) for i, t in enumerate(thetas): noiseless_c.add(gates.RY(i, theta=t)) if np.random.random() < 0.2: noiseless_c.add(gates.X(i)) if np.random.random() < 0.1: noiseless_c.add(gates.Z(i)) target_state.append(noiseless_c().numpy()) target_state = np.stack(target_state) np.testing.assert_allclose(final_state, target_state) qibo.set_backend(original_backend)
def test_toffoli_cirq(backend): import qibo original_backend = qibo.get_backend() qibo.set_backend(backend) c1 = Circuit(3) c1.add(gates.Y(0)) c1.add(gates.TOFFOLI(0, 1, 2)) c1.add(gates.X(1)) c1.add(gates.TOFFOLI(0, 2, 1)) c1.add(gates.Z(2)) c1.add(gates.TOFFOLI(1, 2, 0)) 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 # pylint: disable=no-member 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_z(backend): final_state = apply_gates([gates.H(0), gates.H(1), gates.Z(0)], nqubits=2) target_state = np.ones_like(final_state) / 2.0 target_state[2] *= -1.0 target_state[3] *= -1.0 K.assert_allclose(final_state, target_state)