Add iSWAP and CPhase gates

pennylane_cirq/__init__.py

@@ -19,5 +19,5 @@
 from .qsim_device import QSimDevice, QSimhDevice
 from .pasqal_device import PasqalDevice
 
-from .ops import BitFlip, PhaseFlip, PhaseDamp, AmplitudeDamp, Depolarize
+from .ops import BitFlip, PhaseFlip, PhaseDamp, AmplitudeDamp, Depolarize, ISWAP, CPhase
 from ._version import __version__

pennylane_cirq/cirq_device.py

@@ -132,8 +132,10 @@ def __init__(self, wires, shots, analytic, qubits=None):
         "T": CirqOperation(lambda: cirq.T),
         "CNOT": CirqOperation(lambda: cirq.CNOT),
         "SWAP": CirqOperation(lambda: cirq.SWAP),
+        "ISWAP": CirqOperation(lambda: cirq.ISWAP),
         "CZ": CirqOperation(lambda: cirq.CZ),
         "PhaseShift": CirqOperation(lambda phi: cirq.ZPowGate(exponent=phi / np.pi)),
+        "CPhase": CirqOperation(lambda phi: cirq.CZPowGate(exponent=phi / np.pi)),
         "RX": CirqOperation(cirq.rx),
         "RY": CirqOperation(cirq.ry),
         "RZ": CirqOperation(cirq.rz),

pennylane_cirq/ops.py

@@ -123,3 +123,43 @@ class Depolarize(Operation):
 
     grad_method = None
     grad_recipe = None
+
+
+class ISWAP(Operation):
+    """Cirq ``ISWAP`` operation.
+
+    See the `Cirq docs <https://cirq.readthedocs.io/en/stable/generated/cirq.ISWAP.html>`_
+    for further details."""
+
+    num_params = 0
+    num_wires = 2
+    par_domain = None
+
+    grad_method = None
+    grad_recipe = None
+
+
+class CPhase(Operation):
+    r"""Conditional phase operation following PennyLane conventions.
+
+    Implemented as Cirq ``CZPowGate(exponent=phi / np.pi)``.
+
+    .. math::
+
+        CPhase(\phi) =
+            \begin{bmatrix}
+                [[1, 0, 0, 0],
+                [0, 1, 0, 0],
+                [0, 0, 1, 0],
+                [0, 0, 0, e^{i\phi]]
+            \end{bmatrix}.
+
+    See the `Cirq docs <https://cirq.readthedocs.io/en/stable/generated/cirq.CZPowGate.html>`_
+    for further details."""
+
+    num_params = 1
+    num_wires = 2
+    par_domain = "R"
+
+    grad_method = None
+    grad_recipe = None

tests/test_native_ops.py

@@ -19,7 +19,7 @@
 
 import pennylane as qml
 import numpy as np
-from pennylane_cirq import ops, MixedStateSimulatorDevice
+from pennylane_cirq import ops, MixedStateSimulatorDevice, SimulatorDevice
 import cirq
 
 
@@ -188,3 +188,54 @@ def test_apply_amplitude_damp_single_wire(
         simulator_device_1_wire.apply([ops.AmplitudeDamp(*par, wires=[0])])
 
         assert np.allclose(simulator_device_1_wire.state, expected_density_matrix, **tol)
+
+    @pytest.mark.parametrize("input",
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1],
+        ]
+    )
+    def test_apply_iswap(self, tol, input, shots, analytic):
+        """Tests that applying the CPhase gate yields the expected output."""
+        device = SimulatorDevice(2, shots=shots, analytic=analytic)
+
+        iswap_mat = np.array([[1, 0, 0, 0],
+                              [0, 0, 1j, 0],
+                              [0, 1j, 0, 0],
+                              [0, 0, 0, 1]])
+
+        expected = input @ iswap_mat
+
+        device.reset()
+        device._initial_state = np.array(input, dtype=np.complex64)
+        device.apply([ops.ISWAP(wires=[0, 1])])
+
+        assert np.allclose(device.state, expected, **tol)
+
+    @pytest.mark.parametrize("par", [0, 0.5, 1.42, np.pi/4, np.pi/2, np.pi])
+    @pytest.mark.parametrize("input",
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1],
+        ]
+    )
+    def test_apply_cphase(self, tol, par, input, shots, analytic):
+        """Tests that applying the iSWAP gate yields the expected output."""
+        device = SimulatorDevice(2, shots=shots, analytic=analytic)
+
+        cphase_mat = np.array([[1, 0, 0, 0],
+                               [0, 1, 0, 0],
+                               [0, 0, 1, 0],
+                               [0, 0, 0, np.exp(1j * par)]])
+
+        expected = input @ cphase_mat
+
+        device.reset()
+        device._initial_state = np.array(input, dtype=np.complex64)
+        device.apply([ops.CPhase(par, wires=[0, 1])])
+
+        assert np.allclose(device.state, expected, **tol)