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
