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 _translate_two_qubit_cirq_operation_to_braket_instruction(
op: "cirq.Operation", ) -> List[Instruction]:
"""Translates a two-qubit Cirq operation to a (sequence of) Braket
instruction(s) according to the following rules:
1. Attempts to find a "standard translation" from Cirq to Braket.
- e.g., checks if `op` is a CNOT and, if so, returns the Braket CNOT.
2. If (1) is not successful, performs a KAK decomposition of the unitary of
`op` to obtain a circuit
──A1──X^0.5───@───X^a───X──────────────────@───B1───
│ │ │
──A2──────────X───Y^b───@───X^-0.5───Z^c───X───B2────
where A1, A2, B1, and B2 are arbitrary single-qubit unitaries and a, b, c
are floats.
Args:
op: Two-qubit Cirq operation to translate.
"""
# Translate qubit indices.
q1, q2 = [qubit.x for qubit in op.qubits]
# Check common two-qubit gates.
if isinstance(op.gate, cirq_ops.CNotPowGate) and np.isclose(
abs(op.gate.exponent), 1.0):
return [Instruction(braket_gates.CNot(), [q1, q2])]
elif isinstance(op.gate, cirq_ops.CZPowGate) and np.isclose(
abs(op.gate.exponent), 1.0):
return [Instruction(braket_gates.CZ(), [q1, q2])]
elif isinstance(op.gate, cirq_ops.ISwapPowGate) and np.isclose(
op.gate.exponent, 1.0):
return [Instruction(braket_gates.ISwap(), [q1, q2])]
elif isinstance(op.gate, cirq_ops.XXPowGate):
return [
Instruction(braket_gates.XX(op.gate.exponent * np.pi), [q1, q2])
]
elif isinstance(op.gate, cirq_ops.YYPowGate):
return [
Instruction(braket_gates.YY(op.gate.exponent * np.pi), [q1, q2])
]
elif isinstance(op.gate, cirq_ops.ZZPowGate):
return [
Instruction(braket_gates.ZZ(op.gate.exponent * np.pi), [q1, q2])
]
# Arbitrary two-qubit unitary decomposition.
kak = kak_decomposition(protocols.unitary(op))
A1, A2 = kak.single_qubit_operations_before
x, y, z = kak.interaction_coefficients
a = x * -2 / np.pi + 0.5
b = y * -2 / np.pi + 0.5
c = z * -2 / np.pi + 0.5
B1, B2 = kak.single_qubit_operations_after
return [
*_translate_one_qubit_cirq_operation_to_braket_instruction(A1, q1),
*_translate_one_qubit_cirq_operation_to_braket_instruction(A2, q2),
Instruction(braket_gates.Rx(0.5 * np.pi), q1),
Instruction(braket_gates.CNot(), [q1, q2]),
Instruction(braket_gates.Rx(a * np.pi), q1),
Instruction(braket_gates.Ry(b * np.pi), q2),
Instruction(braket_gates.CNot(), [q2, q1]),
Instruction(braket_gates.Rx(-0.5 * np.pi), q2),
Instruction(braket_gates.Rz(c * np.pi), q2),
Instruction(braket_gates.CNot(), [q1, q2]),
*_translate_one_qubit_cirq_operation_to_braket_instruction(B1, q1),
*_translate_one_qubit_cirq_operation_to_braket_instruction(B2, q2),
]
def _(iswap: ISWAP, _parameters):
return gates.PSwap(3 * np.pi / 2) if iswap.inverse else gates.ISwap()
(Circuit().s(0), gates.S().to_matrix()),
(Circuit().si(0), gates.Si().to_matrix()),
(Circuit().t(0), gates.T().to_matrix()),
(Circuit().ti(0), gates.Ti().to_matrix()),
(Circuit().v(0), gates.V().to_matrix()),
(Circuit().vi(0), gates.Vi().to_matrix()),
(Circuit().rx(0, 0.15), gates.Rx(0.15).to_matrix()),
(Circuit().ry(0, 0.15), gates.Ry(0.15).to_matrix()),
(Circuit().rz(0, 0.15), gates.Rz(0.15).to_matrix()),
(Circuit().phaseshift(0, 0.15), gates.PhaseShift(0.15).to_matrix()),
(Circuit().cnot(1, 0), gates.CNot().to_matrix()),
(Circuit().cnot(1, 0).add_result_type(
ResultType.StateVector()), gates.CNot().to_matrix()),
(Circuit().swap(1, 0), gates.Swap().to_matrix()),
(Circuit().swap(0, 1), gates.Swap().to_matrix()),
(Circuit().iswap(1, 0), gates.ISwap().to_matrix()),
(Circuit().iswap(0, 1), gates.ISwap().to_matrix()),
(Circuit().pswap(1, 0, 0.15), gates.PSwap(0.15).to_matrix()),
(Circuit().pswap(0, 1, 0.15), gates.PSwap(0.15).to_matrix()),
(Circuit().xy(1, 0, 0.15), gates.XY(0.15).to_matrix()),
(Circuit().xy(0, 1, 0.15), gates.XY(0.15).to_matrix()),
(Circuit().cphaseshift(1, 0,
0.15), gates.CPhaseShift(0.15).to_matrix()),
(Circuit().cphaseshift00(1, 0,
0.15), gates.CPhaseShift00(0.15).to_matrix()),
(Circuit().cphaseshift01(1, 0,
0.15), gates.CPhaseShift01(0.15).to_matrix()),
(Circuit().cphaseshift10(1, 0,
0.15), gates.CPhaseShift10(0.15).to_matrix()),
(Circuit().cy(1, 0), gates.CY().to_matrix()),
(Circuit().cz(1, 0), gates.CZ().to_matrix()),