def test_interchangeable_qubit_eq():
a = ops.NamedQubit('a')
b = ops.NamedQubit('b')
c = ops.NamedQubit('c')
eq = EqualsTester()
eq.add_equality_group(ops.SWAP(a, b), ops.SWAP(b, a))
eq.add_equality_group(ops.SWAP(a, c))
eq.add_equality_group(ops.CZ(a, b), ops.CZ(b, a))
eq.add_equality_group(ops.CZ(a, c))
eq.add_equality_group(ops.CNOT(a, b))
eq.add_equality_group(ops.CNOT(b, a))
eq.add_equality_group(ops.CNOT(a, c))
def swap_rzz(theta: float, q0: ops.Qid, q1: ops.Qid) -> ops.OP_TREE:
"""
An implementation of SWAP * EXP(1j theta ZZ) using three sycamore gates.
This builds off of the zztheta method. A sycamore gate following the
zz-gate is a SWAP EXP(1j (THETA - pi/24) ZZ).
Args:
theta: exp(1j * theta )
q0: First qubit id to operate on
q1: Second qubit id to operate on
Returns:
The circuit that implements ZZ followed by a swap
"""
# Set interaction part.
circuit = circuits.Circuit()
angle_offset = np.pi / 24 - np.pi / 4
circuit.append(google.SYC(q0, q1))
circuit.append(rzz(theta - angle_offset, q0, q1))
# Get the intended circuit.
intended_circuit = circuits.Circuit(
ops.SWAP(q0, q1),
ops.ZZPowGate(exponent=2 * theta / np.pi,
global_shift=-0.5).on(q0, q1))
yield create_corrected_circuit(intended_circuit, circuit, q0, q1)
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 _SWAP(
q1: int,
q2: int,
args: sim.ActOnCliffordTableauArgs,
operations: List[ops.Operation],
qubits: List['cirq.Qid'],
):
protocols.act_on(ops.SWAP, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
operations.append(ops.SWAP(qubits[q1], qubits[q2]))
def test_text_diagrams():
a = ops.NamedQubit('a')
b = ops.NamedQubit('b')
circuit = Circuit.from_ops(ops.SWAP(a, b), ops.X(a), ops.Y(a), ops.Z(a),
ops.CZ(a, b), ops.CNOT(a, b), ops.CNOT(b, a),
ops.H(a))
assert circuit.to_text_diagram().strip() == """
a: ───×───X───Y───Z───@───@───X───H───
│ │ │ │
b: ───×───────────────@───X───@───────
""".strip()
def test_works_with_basic_gates():
a = ops.NamedQubit('a')
b = ops.NamedQubit('b')
basics = [
ops.X(a),
ops.Y(a)**0.5,
ops.Z(a),
ops.CZ(a, b)**-0.25,
ops.CNOT(a, b),
ops.H(b),
ops.SWAP(a, b)
]
assert list(ops.inverse_of_invertible_op_tree(basics)) == [
ops.SWAP(a, b),
ops.H(b),
ops.CNOT(a, b),
ops.CZ(a, b)**0.25,
ops.Z(a),
ops.Y(a)**-0.5,
ops.X(a),
]
def operations(self) -> 'cirq.OP_TREE':
if len(self._qubits) != 2:
raise ValueError('Wrong number of swap gates in a column.')
return ops.SWAP(*self._qubits).controlled_by(*self._controls)