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)
def _translate_one_qubit_cirq_operation_to_braket_instruction(
op: Union[np.ndarray, "cirq.Operation"],
target: Optional[int] = None,
) -> List[Instruction]:
"""Translates a one-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 Pauli-X and, if so, returns the Braket X.
2. If (1) is not successful, decomposes the unitary of `op` to
Rz(theta) Ry(phi) Rz(lambda) and returns the series of rotations as Braket
instructions.
Args:
op: One-qubit Cirq operation to translate.
target: Qubit index for the op to act on. Must be specified and if only
if `op` is given as a numpy array.
"""
# Translate qubit index.
if not isinstance(op, np.ndarray):
target = op.qubits[0].x
if target is None:
raise ValueError(
"Arg `target` must be specified when `op` is a matrix.")
# Check common single-qubit gates.
if isinstance(op, cirq_ops.Operation):
if isinstance(op.gate, cirq_ops.XPowGate):
exponent = op.gate.exponent
if np.isclose(exponent, 1.0) or np.isclose(exponent, -1.0):
return [Instruction(braket_gates.X(), target)]
elif np.isclose(exponent, 0.5):
return [Instruction(braket_gates.V(), target)]
elif np.isclose(exponent, -0.5):
return [Instruction(braket_gates.Vi(), target)]
return [Instruction(braket_gates.Rx(exponent * np.pi), target)]
elif isinstance(op.gate, cirq_ops.YPowGate):
exponent = op.gate.exponent
if np.isclose(exponent, 1.0) or np.isclose(exponent, -1.0):
return [Instruction(braket_gates.Y(), target)]
return [Instruction(braket_gates.Ry(exponent * np.pi), target)]
elif isinstance(op.gate, cirq_ops.ZPowGate):
exponent = op.gate.exponent
if np.isclose(exponent, 1.0) or np.isclose(exponent, -1.0):
return [Instruction(braket_gates.Z(), target)]
elif np.isclose(exponent, 0.5):
return [Instruction(braket_gates.S(), target)]
elif np.isclose(exponent, -0.5):
return [Instruction(braket_gates.Si(), target)]
elif np.isclose(exponent, 0.25):
return [Instruction(braket_gates.T(), target)]
elif np.isclose(exponent, -0.25):
return [Instruction(braket_gates.Ti(), target)]
return [Instruction(braket_gates.Rz(exponent * np.pi), target)]
elif isinstance(op.gate, cirq_ops.HPowGate) and np.isclose(
abs(op.gate.exponent), 1.0):
return [Instruction(braket_gates.H(), target)]
# Arbitrary single-qubit unitary decomposition.
# TODO: This does not account for global phase.
if isinstance(op, cirq_ops.Operation):
unitary_matrix = protocols.unitary(op)
else:
unitary_matrix = op
a, b, c = deconstruct_single_qubit_matrix_into_angles(unitary_matrix)
return [
Instruction(braket_gates.Rz(a), target),
Instruction(braket_gates.Ry(b), target),
Instruction(braket_gates.Rz(c), target),
]
def _(y: qml.PauliY, _parameters):
return gates.Y()
import functools
import itertools
import math
import numpy as np
import pytest
from braket.circuits import gates
from braket.circuits.observables import X, Y, Z
from braket.quantum_information import PauliString
ORDER = ["I", "X", "Y", "Z"]
PAULI_INDEX_MATRICES = {
0: gates.I().to_matrix(),
1: gates.X().to_matrix(),
2: gates.Y().to_matrix(),
3: gates.Z().to_matrix(),
}
SIGN_MAP = {"+": 1, "-": -1}
@pytest.mark.parametrize(
"pauli_string, string, phase, observable",
[
("+XZ", "+XZ", 1, X() @ Z()),
("-ZXY", "-ZXY", -1, Z() @ X() @ Y()),
("YIX", "+YIX", 1, Y() @ X()),
(PauliString("-ZYXI"), "-ZYXI", -1, Z() @ Y() @ X()),
],
)
def test_happy_case(pauli_string, string, phase, observable):
assert np.allclose(
circuit.as_unitary(),
np.kron(gates.Si().to_matrix(),
np.kron(gates.CPhaseShift(0.15).to_matrix(), np.eye(2))),
)
@pytest.mark.parametrize(
"circuit,expected_unitary",
[
(Circuit().h(0), gates.H().to_matrix()),
(Circuit().h(0).add_result_type(
ResultType.Probability(target=[0])), gates.H().to_matrix()),
(Circuit().x(0), gates.X().to_matrix()),
(Circuit().y(0), gates.Y().to_matrix()),
(Circuit().z(0), gates.Z().to_matrix()),
(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()),