def test_from_circuit_with_verbatim(device_arn, device_parameters_class, disable_qubit_rewiring, aws_session): circ = Circuit().add_verbatim_box(Circuit().h(0)) mocked_task_arn = "task-arn-1" aws_session.create_quantum_task.return_value = mocked_task_arn shots = 1337 task = AwsQuantumTask.create( aws_session, device_arn, circ, S3_TARGET, shots, disable_qubit_rewiring=disable_qubit_rewiring, ) assert task == AwsQuantumTask(mocked_task_arn, aws_session) serialization_properties = OpenQASMSerializationProperties( qubit_reference_type=QubitReferenceType.PHYSICAL) _assert_create_quantum_task_called_with( aws_session, device_arn, circ.to_ir( ir_type=IRType.OPENQASM, serialization_properties=serialization_properties, ).json(), S3_TARGET, shots, device_parameters_class(paradigmParameters=GateModelParameters( qubitCount=circ.qubit_count, disableQubitRewiring=disable_qubit_rewiring)), )
def many_layers(n_qubits: int, n_layers: int) -> Circuit: """ Function to return circuit with many layers. :param int n_qubits: number of qubits :param int n_layers: number of layers :return: Constructed easy circuit :rtype: Circuit """ qubits = range(n_qubits) circuit = Circuit() # instantiate circuit object for q in range(n_qubits): circuit.h(q) for layer in range(n_layers): if (layer + 1) % 100 != 0: for qubit in range(len(qubits)): angle = np.random.uniform(0, 2 * math.pi) gate = np.random.choice( [Gate.Rx(angle), Gate.Ry(angle), Gate.Rz(angle), Gate.H()], 1, replace=True )[0] circuit.add_instruction(Instruction(gate, qubit)) else: for q in range(0, n_qubits, 2): circuit.cnot(q, q + 1) for q in range(1, n_qubits - 1, 2): circuit.cnot(q, q + 1) return circuit
def test_from_braket_parameterized_single_qubit_gates(qubit_index): braket_circuit = BKCircuit() pgates = [ braket_gates.Rx, braket_gates.Ry, braket_gates.Rz, braket_gates.PhaseShift, ] angles = np.random.RandomState(11).random(len(pgates)) instructions = [ Instruction(rot(a), target=qubit_index) for rot, a in zip(pgates, angles) ] for instr in instructions: braket_circuit.add_instruction(instr) cirq_circuit = from_braket(braket_circuit) for i, op in enumerate(cirq_circuit.all_operations()): assert np.allclose(instructions[i].operator.to_matrix(), protocols.unitary(op)) qubit = LineQubit(qubit_index) expected_cirq_circuit = Circuit( ops.rx(angles[0]).on(qubit), ops.ry(angles[1]).on(qubit), ops.rz(angles[2]).on(qubit), ops.Z.on(qubit)**(angles[3] / np.pi), ) assert _equal(cirq_circuit, expected_cirq_circuit, require_qubit_equality=True)
def controlled_unitary(control, target_qubits, unitary): """ Construct a circuit object corresponding to the controlled unitary Args: control: The qubit on which to control the gate target_qubits: List of qubits on which the unitary U acts unitary: matrix representation of the unitary we wish to implement in a controlled way """ # Define projectors onto the computational basis p0 = np.array([[1., 0.], [0., 0.]]) p1 = np.array([[0., 0.], [0., 1.]]) # Instantiate circuit object circ = Circuit() # Construct numpy matrix id_matrix = np.eye(len(unitary)) controlled_matrix = np.kron(p0, id_matrix) + np.kron(p1, unitary) # Set all target qubits targets = [control] + target_qubits # Add controlled unitary circ.unitary(matrix=controlled_matrix, targets=targets) return circ
def test_from_braket_parameterized_two_qubit_gates(): pgates = [ braket_gates.CPhaseShift, braket_gates.CPhaseShift00, braket_gates.CPhaseShift01, braket_gates.CPhaseShift10, braket_gates.PSwap, braket_gates.XX, braket_gates.YY, braket_gates.ZZ, braket_gates.XY, ] angles = np.random.RandomState(2).random(len(pgates)) instructions = [ Instruction(rot(a), target=[0, 1]) for rot, a in zip(pgates, angles) ] cirq_circuits = list() for instr in instructions: braket_circuit = BKCircuit() braket_circuit.add_instruction(instr) cirq_circuits.append(from_braket(braket_circuit)) for instr, cirq_circuit in zip(instructions, cirq_circuits): assert np.allclose(instr.operator.to_matrix(), cirq_circuit.unitary())
def test_add_verbatim_box_with_target(cnot): circ = Circuit().add_verbatim_box(cnot, target=[10, 11]) expected = (Circuit().add_instruction( Instruction(compiler_directives.StartVerbatimBox())).add_instruction( Instruction(Gate.CNot(), [10, 11])).add_instruction( Instruction(compiler_directives.EndVerbatimBox()))) assert circ == expected
def test_from_braket_non_parameterized_two_qubit_gates(): braket_circuit = BKCircuit() instructions = [ Instruction(braket_gates.CNot(), target=[2, 3]), Instruction(braket_gates.Swap(), target=[3, 4]), Instruction(braket_gates.ISwap(), target=[2, 3]), Instruction(braket_gates.CZ(), target=(3, 4)), Instruction(braket_gates.CY(), target=(2, 3)), ] for instr in instructions: braket_circuit.add_instruction(instr) cirq_circuit = from_braket(braket_circuit) qreg = LineQubit.range(2, 5) expected_cirq_circuit = Circuit( ops.CNOT(*qreg[:2]), ops.SWAP(*qreg[1:]), ops.ISWAP(*qreg[:2]), ops.CZ(*qreg[1:]), ops.ControlledGate(ops.Y).on(*qreg[:2]), ) assert np.allclose( protocols.unitary(cirq_circuit), protocols.unitary(expected_cirq_circuit), )
def test_from_circuit_with_verbatim(device_arn, device_parameters_class, aws_session): circ = Circuit().add_verbatim_box(Circuit().h(0)) mocked_task_arn = "task-arn-1" aws_session.create_quantum_task.return_value = mocked_task_arn shots = 1337 task = AwsQuantumTask.create( aws_session, device_arn, circ, S3_TARGET, shots, disable_qubit_rewiring=True, ) assert task == AwsQuantumTask(mocked_task_arn, aws_session) _assert_create_quantum_task_called_with( aws_session, device_arn, circ, S3_TARGET, shots, device_parameters_class(paradigmParameters=GateModelParameters( qubitCount=circ.qubit_count, disableQubitRewiring=True)), )
def multithreaded_bell_pair_testing(device: Device, run_kwargs: Dict[str, Any]): shots = run_kwargs["shots"] tol = get_tol(shots) bell = Circuit().h(0).cnot(0, 1) def run_circuit(circuit): task = device.run(circuit, **run_kwargs) return task.result() futures = [] num_threads = 2 tasks = (bell, bell.to_ir(ir_type=IRType.OPENQASM)) for task in tasks: with concurrent.futures.ThreadPoolExecutor() as executor: for _ in range(num_threads): future = executor.submit(run_circuit, task) futures.append(future) for future in futures: result = future.result() assert np.allclose(result.measurement_probabilities["00"], 0.5, **tol) assert np.allclose(result.measurement_probabilities["11"], 0.5, **tol) assert len(result.measurements) == shots
def test_apply(): noise_model = (NoiseModel().add_noise(PauliChannel( 0.01, 0.02, 0.03), GateCriteria(Gate.I, [0, 1])).add_noise( Depolarizing(0.04), GateCriteria(Gate.H)).add_noise( TwoQubitDepolarizing(0.05), GateCriteria(Gate.CNot, [0, 1])).add_noise( PauliChannel(0.06, 0.07, 0.08), GateCriteria(Gate.H, [0, 1])).add_noise( Depolarizing(0.10), UnitaryGateCriteria(h_unitary(), 0)).add_noise( Depolarizing(0.06), ObservableCriteria(Observable.Z, 0)).add_noise( Depolarizing(0.09), QubitInitializationCriteria(0))) layer1 = Circuit().h(0).cnot(0, 1).sample(Observable.Z(), 0) layer2 = Circuit().unitary([0], h_unitary().to_matrix()) circuit = layer1 + layer2 noisy_circuit_from_circuit = noise_model.apply(circuit) expected_circuit = (Circuit().depolarizing(0, 0.09).h(0).depolarizing( 0, 0.04).pauli_channel(0, 0.06, 0.07, 0.08).cnot( 0, 1).two_qubit_depolarizing(0, 1, 0.05).unitary( [0], h_unitary().to_matrix()).depolarizing( 0, 0.10).apply_readout_noise(Depolarizing(0.06), 0).sample(Observable.Z(), 0)) assert noisy_circuit_from_circuit == expected_circuit
def qaa(A, flag_qubit, num_iterations, qubits=None, use_explicit_unitary=False): """ Function to implement the Quantum Amplitude Amplification Q^m, where Q=A R_0 A* R_B, m=num_iterations. Args: A: Circuit defining the unitary A flag_qubit: Specifies which of the qubits A acts on labels the good/bad subspace. Must be an element of qubits (if passed) or A.qubits. num_iterations: number of applications of the Grover iterator Q. qubits: list of qubits on which to apply the gates (including the flag_qubit). If qubits is different from A.qubits, A is applied to qubits instead. use_explicit_unitary: Flag to specify that we should implement R_0 using using a custom gate defined by the unitary diag(-1,1,...,1). Default is False. """ # Instantiate the circuit circ = Circuit() # Apply the Grover iterator num_iterations times: for _ in range(num_iterations): circ.grover_iterator(A, flag_qubit, qubits, use_explicit_unitary) return circ
def no_result_types_bell_pair_testing(device: Device, run_kwargs: Dict[str, Any]): bell = Circuit().h(0).cnot(0, 1) bell_qasm = bell.to_ir(ir_type=IRType.OPENQASM) for task in (bell, bell_qasm): no_result_types_testing(task, device, run_kwargs, { "00": 0.5, "11": 0.5 })
def test_add_verbatim_box_no_preceding(): circ = Circuit().add_verbatim_box(Circuit().h(0)).cnot(2, 3) expected = (Circuit().add_instruction( Instruction(compiler_directives.StartVerbatimBox())).add_instruction( Instruction(Gate.H(), 0)).add_instruction( Instruction( compiler_directives.EndVerbatimBox())).add_instruction( Instruction(Gate.CNot(), [2, 3]))) assert circ == expected
def test_from_braket_raises_on_unsupported_gates(): for num_qubits in range(1, 5): braket_circuit = BKCircuit() instr = Instruction( braket_gates.Unitary(_rotation_of_pi_over_7(num_qubits)), target=list(range(num_qubits)), ) braket_circuit.add_instruction(instr) with pytest.raises(ValueError): from_braket(braket_circuit)
def qubit_ordering_testing(device: Device, run_kwargs: Dict[str, Any]): # |110> should get back value of "110" state_110 = Circuit().x(0).x(1).i(2) result = device.run(state_110, **run_kwargs).result() assert result.measurement_counts.most_common(1)[0][0] == "110" # |001> should get back value of "001" state_001 = Circuit().i(0).i(1).x(2) result = device.run(state_001, **run_kwargs).result() assert result.measurement_counts.most_common(1)[0][0] == "001"
def test_apply_in_order(): noise_model = (NoiseModel().add_noise(Depolarizing(0.01), GateCriteria(Gate.H)).add_noise( Depolarizing(0.02), GateCriteria(Gate.H))) circuit = Circuit().h(0) noisy_circuit = noise_model.apply(circuit) expected_circuit = circuit.apply_gate_noise( [Depolarizing(0.01), Depolarizing(0.02)]) assert noisy_circuit == expected_circuit
def test_verbatim_1q_following(): circ = Circuit().add_verbatim_box(Circuit().h(0)).h(0) expected = ( "T : | 0 |1| 2 |3|", " ", "q0 : -StartVerbatim-H-EndVerbatim-H-", "", "T : | 0 |1| 2 |3|", ) _assert_correct_diagram(circ, expected)
def qft_no_swap(qubits): """ Subroutine of the QFT excluding the final SWAP gates, applied to the qubits argument. Returns the a circuit object. Args: qubits (int): The list of qubits on which to apply the QFT """ # On a single qubit, the QFT is just a Hadamard. if len(qubits) == 1: return Circuit().h(qubits) # For more than one qubit, we define the QFT recursively (as shown on the right half of the image above): else: qftcirc = Circuit() # First add a Hadamard gate qftcirc.h(qubits[0]) # Then apply the controlled rotations, with weights (angles) defined by the distance to the control qubit. for k, qubit in enumerate(qubits[1:]): qftcirc.cphaseshift(qubit, qubits[0], 2*math.pi/(2**(k+2))) # Now apply the above gates recursively to the rest of the qubits qftcirc.add(qft_no_swap(qubits[1:])) return qftcirc
def test_add_verbatim_box_different_qubits(): circ = Circuit().h(1).add_verbatim_box(Circuit().h(0)).cnot(3, 4) expected = (Circuit().add_instruction(Instruction( Gate.H(), 1)).add_instruction(Instruction( compiler_directives.StartVerbatimBox())).add_instruction( Instruction(Gate.H(), 0)).add_instruction( Instruction( compiler_directives.EndVerbatimBox())).add_instruction( Instruction(Gate.CNot(), [3, 4]))) assert circ == expected
def test_verbatim_1q_following(): circ = Circuit().add_verbatim_box(Circuit().h(0)).h(0) expected = ( "T : | 0 |1| 2 |3|", " ", "q0 : -StartVerbatim-H-EndVerbatim-H-", "", "T : | 0 |1| 2 |3|", ) expected = "\n".join(expected) assert AsciiCircuitDiagram.build_diagram(circ) == expected
def ZZgate(q1, q2, gamma): """ function that returns a circuit implementing exp(-i \gamma Z_i Z_j) using CNOT gates if ZZ not supported """ # get a circuit circ_zz = Circuit() # construct decomposition of ZZ circ_zz.cnot(q1, q2).rz(q2, gamma).cnot(q1, q2) return circ_zz