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 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_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 to_braket(circuit: Circuit) -> BKCircuit:
"""Returns a Braket circuit equivalent to the input Cirq circuit.
Args:
circuit: Cirq circuit to convert to a Braket circuit.
"""
return BKCircuit(
_translate_cirq_operation_to_braket_instruction(op)
for op in circuit.all_operations())
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 test_from_braket_three_qubit_gates():
braket_circuit = BKCircuit()
instructions = [
Instruction(braket_gates.CCNot(), target=[1, 2, 3]),
Instruction(braket_gates.CSwap(), target=[1, 2, 3]),
]
for instr in instructions:
braket_circuit.add_instruction(instr)
cirq_circuit = from_braket(braket_circuit)
qreg = LineQubit.range(1, 4)
expected_cirq_circuit = Circuit(ops.TOFFOLI(*qreg), ops.FREDKIN(*qreg))
assert np.allclose(
protocols.unitary(cirq_circuit),
protocols.unitary(expected_cirq_circuit),
)
def test_from_braket_parameterized_two_qubit_gates():
braket_circuit = BKCircuit()
# TODO: Add all two-qubit parameterized gates once translated.
pgates = [
braket_gates.CPhaseShift,
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)
]
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))
def test_from_braket_non_parameterized_single_qubit_gates():
braket_circuit = BKCircuit()
instructions = [
Instruction(braket_gates.I(), target=0),
Instruction(braket_gates.X(), target=1),
Instruction(braket_gates.Y(), target=2),
Instruction(braket_gates.Z(), target=3),
Instruction(braket_gates.H(), target=0),
Instruction(braket_gates.S(), target=1),
Instruction(braket_gates.Si(), target=2),
Instruction(braket_gates.T(), target=3),
Instruction(braket_gates.Ti(), target=0),
Instruction(braket_gates.V(), target=1),
Instruction(braket_gates.Vi(), target=2),
]
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)
)
qreg = LineQubit.range(4)
expected_cirq_circuit = Circuit(
ops.I(qreg[0]),
ops.X(qreg[1]),
ops.Y(qreg[2]),
ops.Z(qreg[3]),
ops.H(qreg[0]),
ops.S(qreg[1]),
ops.S(qreg[2]) ** -1,
ops.T(qreg[3]),
ops.T(qreg[0]) ** -1,
ops.X(qreg[1]) ** 0.5,
ops.X(qreg[2]) ** -0.5,
)
assert _equal(cirq_circuit, expected_cirq_circuit)
cirq_qreg = cirq.LineQubit.range(2)
cirq_circuit = cirq.Circuit(cirq.ops.H.on(cirq_qreg[0]),
cirq.ops.CNOT.on(*cirq_qreg))
# Qiskit Bell circuit.
qiskit_qreg = qiskit.QuantumRegister(2)
qiskit_circuit = qiskit.QuantumCircuit(qiskit_qreg)
qiskit_circuit.h(qiskit_qreg[0])
qiskit_circuit.cnot(*qiskit_qreg)
# pyQuil Bell circuit.
pyquil_circuit = Program(gates.H(0), gates.CNOT(0, 1))
# Braket Bell circuit.
braket_circuit = BKCircuit([
Instruction(braket_gates.H(), 0),
Instruction(braket_gates.CNot(), [0, 1]),
])
circuit_types = {
"qiskit": qiskit.QuantumCircuit,
"pyquil": Program,
"braket": BKCircuit,
}
@noise_scaling_converter
def scaling_function(circ: cirq.Circuit, *args, **kwargs) -> cirq.Circuit:
return circ
@pytest.mark.parametrize("circuit",
