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),
)
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",
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 _(cnot: qml.CNOT, _parameters):
return gates.CNot()
# # "cu3": CU3Gate,
# "ccx": gates.CCNot,
# "cswap": gates.CSwap
# }
# TODO: look into a possibility to use device's native gates set (no the IBMQ natives!)
# First element is executed first!
_qiskit_2_braket_conversion = {
"u1": lambda lam: [gates.Rz(lam)],
"u2": lambda phi, lam: [gates.Rz(lam), gates.Ry(numpy.pi/2), gates.Rz(phi)],
"u3": lambda theta, phi, lam: [gates.Rz(lam),
gates.Rx(numpy.pi/2),
gates.Rz(theta),
gates.Rx(-numpy.pi/2),
gates.Rz(phi)],
"cx": lambda: [gates.CNot()]
}
def convert_experiment(experiment: QasmQobjExperiment) -> Circuit:
qc = Circuit()
qasm_obj_instruction: QasmQobjInstruction
for qasm_obj_instruction in experiment.instructions:
name = qasm_obj_instruction.name
if name == 'measure':
qc.add_result_type(result_types.Probability(qasm_obj_instruction.qubits))
elif name == 'barrier':
# This does not exist
pass
else:
(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()),
(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,
