Adds the quantum fourier transform and controlled phase operations

.github/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 <h3>New features since last release</h3>
 
+- Added the `ControlledPhaseShift` gate as well as the `QFT` operation for applying quantum Fourier
+  transforms.
+  [(#1064)](https://github.com/PennyLaneAI/pennylane/pull/1064)
+
 <h3>Improvements</h3>
 
 <h3>Breaking changes</h3>
@@ -14,7 +18,7 @@
 
 This release contains contributions from (in alphabetical order):
 
-
+Thomas Bromley
 
 # Release 0.14.0 (current release)
 

doc/introduction/operations.rst

@@ -66,6 +66,7 @@ Qubit gates
     ~pennylane.MultiRZ
     ~pennylane.PauliRot
     ~pennylane.PhaseShift
+    ~pennylane.ControlledPhaseShift
     ~pennylane.CNOT
     ~pennylane.CZ
     ~pennylane.CY
@@ -81,6 +82,7 @@ Qubit gates
     ~pennylane.CSWAP
     ~pennylane.QubitUnitary
     ~pennylane.DiagonalQubitUnitary
+    ~pennylane.QFT
 
 :html:`</div>`
 

pennylane/devices/autograd_ops.py

@@ -50,6 +50,18 @@ def PhaseShift(phi):
     return np.array([1.0, np.exp(1j * phi)])
 
 
+def ControlledPhaseShift(phi):
+    r"""Two-qubit controlled phase shift.
+
+    Args:
+        phi (float): phase shift angle
+
+    Returns:
+        array[complex]: diagonal part of the controlled phase shift matrix
+    """
+    return np.array([1.0, 1.0, 1.0, np.exp(1j * phi)])
+
+
 def RX(theta):
     r"""One-qubit rotation about the x axis.
 

pennylane/devices/default_mixed.py

@@ -77,6 +77,7 @@ class DefaultMixed(QubitDevice):
         "Toffoli",
         "CZ",
         "PhaseShift",
+        "ControlledPhaseShift",
         "RX",
         "RY",
         "RZ",
@@ -92,6 +93,7 @@ class DefaultMixed(QubitDevice):
         "BitFlip",
         "PhaseFlip",
         "QubitChannel",
+        "QFT",
     }
 
     def __init__(self, wires, *, shots=1000, analytic=True, cache=0):

pennylane/devices/default_qubit.py

@@ -113,6 +113,7 @@ class DefaultQubit(QubitDevice):
         "CY",
         "CZ",
         "PhaseShift",
+        "ControlledPhaseShift",
         "RX",
         "RY",
         "RZ",
@@ -121,6 +122,7 @@ class DefaultQubit(QubitDevice):
         "CRY",
         "CRZ",
         "CRot",
+        "QFT",
     }
 
     observables = {"PauliX", "PauliY", "PauliZ", "Hadamard", "Hermitian", "Identity"}

pennylane/devices/default_qubit_autograd.py

@@ -85,6 +85,7 @@ class DefaultQubitAutograd(DefaultQubit):
 
     parametric_ops = {
         "PhaseShift": autograd_ops.PhaseShift,
+        "ControlledPhaseShift": autograd_ops.ControlledPhaseShift,
         "RX": autograd_ops.RX,
         "RY": autograd_ops.RY,
         "RZ": autograd_ops.RZ,

pennylane/devices/default_qubit_jax.py

@@ -136,6 +136,7 @@ def circuit():
 
     parametric_ops = {
         "PhaseShift": jax_ops.PhaseShift,
+        "ControlledPhaseShift": jax_ops.ControlledPhaseShift,
         "RX": jax_ops.RX,
         "RY": jax_ops.RY,
         "RZ": jax_ops.RZ,

pennylane/devices/default_qubit_tf.py

@@ -133,6 +133,7 @@ class DefaultQubitTF(DefaultQubit):
 
     parametric_ops = {
         "PhaseShift": tf_ops.PhaseShift,
+        "ControlledPhaseShift": tf_ops.ControlledPhaseShift,
         "RX": tf_ops.RX,
         "RY": tf_ops.RY,
         "RZ": tf_ops.RZ,

pennylane/devices/jax_ops.py

@@ -50,6 +50,18 @@ def PhaseShift(phi):
     return jnp.array([1.0, jnp.exp(1j * phi)])
 
 
+def ControlledPhaseShift(phi):
+    r"""Two-qubit controlled phase shift.
+
+    Args:
+        phi (float): phase shift angle
+
+    Returns:
+        array[complex]: diagonal part of the controlled phase shift matrix
+    """
+    return jnp.array([1.0, 1.0, 1.0, jnp.exp(1j * phi)])
+
+
 def RX(theta):
     r"""One-qubit rotation about the x axis.
 

pennylane/devices/tests/test_gates.py

@@ -53,6 +53,7 @@
     "PauliY": qml.PauliY(wires=[0]),
     "PauliZ": qml.PauliZ(wires=[0]),
     "PhaseShift": qml.PhaseShift(0, wires=[0]),
+    "ControlledPhaseShift": qml.ControlledPhaseShift(0, wires=[0, 1]),
     "QubitStateVector": qml.QubitStateVector(np.array([1.0, 0.0]), wires=[0]),
     "QubitUnitary": qml.QubitUnitary(np.eye(2), wires=[0]),
     "RX": qml.RX(0, wires=[0]),
@@ -64,6 +65,7 @@
     "T": qml.T(wires=[0]),
     "SX": qml.SX(wires=[0]),
     "Toffoli": qml.Toffoli(wires=[0, 1, 2]),
+    "QFT": qml.QFT(wires=[0, 1, 2]),
 }
 
 all_ops = ops.keys()

pennylane/devices/tf_ops.py

@@ -51,6 +51,19 @@ def PhaseShift(phi):
     return tf.convert_to_tensor([1.0, tf.exp(1j * phi)])
 
 
+def ControlledPhaseShift(phi):
+    r"""Two-qubit controlled phase shift.
+
+    Args:
+        phi (float): phase shift angle
+
+    Returns:
+        tf.Tensor[complex]: diagonal part of the controlled phase shift matrix
+    """
+    phi = tf.cast(phi, dtype=C_DTYPE)
+    return tf.convert_to_tensor([1.0, 1.0, 1.0, tf.exp(1j * phi)])
+
+
 def RX(theta):
     r"""One-qubit rotation about the x axis.
 

pennylane/ops/qubit.py

@@ -15,17 +15,19 @@
 This module contains the available built-in discrete-variable
 quantum operations supported by PennyLane, as well as their conventions.
 """
-# pylint:disable=abstract-method,arguments-differ,protected-access
-import math
 import cmath
 import functools
+
+# pylint:disable=abstract-method,arguments-differ,protected-access
+import math
+
 import numpy as np
 
+import pennylane as qml
+from pennylane.operation import AnyWires, DiagonalOperation, Observable, Operation
 from pennylane.templates import template
-from pennylane.operation import AnyWires, Observable, Operation, DiagonalOperation
 from pennylane.templates.state_preparations import BasisStatePreparation, MottonenStatePreparation
-from pennylane.utils import pauli_eigs, expand
-import pennylane as qml
+from pennylane.utils import expand, pauli_eigs
 
 INV_SQRT2 = 1 / math.sqrt(2)
 
@@ -722,6 +724,58 @@ def decomposition(phi, wires):
         return decomp_ops
 
 
+class ControlledPhaseShift(DiagonalOperation):
+    r"""ControlledPhaseShift(phi, wires)
+    A qubit controlled phase shift.
+
+    .. math:: CR_\phi(\phi) = \begin{bmatrix}
+                1 & 0 & 0 & 0 \\
+                0 & 1 & 0 & 0 \\
+                0 & 0 & 1 & 0 \\
+                0 & 0 & 0 & e^{i\phi}
+            \end{bmatrix}.
+
+    .. note:: The first wire provided corresponds to the **control qubit**.
+
+    **Details:**
+
+    * Number of wires: 2
+    * Number of parameters: 1
+    * Gradient recipe: :math:`\frac{d}{d\phi}f(CR_\phi(\phi)) = \frac{1}{2}\left[f(CR_\phi(\phi+\pi/2)) - f(CR_\phi(\phi-\pi/2))\right]`
+      where :math:`f` is an expectation value depending on :math:`CR_{\phi}(\phi)`.
+
+    Args:
+        phi (float): rotation angle :math:`\phi`
+        wires (Sequence[int] or int): the wire the operation acts on
+    """
+    num_params = 1
+    num_wires = 2
+    par_domain = "R"
+    grad_method = "A"
+    generator = [np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1]]), 1]
+
+    @classmethod
+    def _matrix(cls, *params):
+        phi = params[0]
+        return np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, cmath.exp(1j * phi)]])
+
+    @classmethod
+    def _eigvals(cls, *params):
+        phi = params[0]
+        return np.array([1, 1, 1, cmath.exp(1j * phi)])
+
+    @staticmethod
+    def decomposition(phi, wires):
+        decomp_ops = [
+            qml.PhaseShift(phi / 2, wires=wires[0]),
+            qml.CNOT(wires=[0, 1]),
+            qml.PhaseShift(-phi / 2, wires=wires[1]),
+            qml.CNOT(wires=[0, 1]),
+            qml.PhaseShift(phi / 2, wires=wires[1]),
+        ]
+        return decomp_ops
+
+
 class Rot(Operation):
     r"""Rot(phi, theta, omega, wires)
     Arbitrary single qubit rotation
@@ -905,7 +959,7 @@ class PauliRot(Operation):
     }
 
     def __init__(self, *params, wires=None, do_queue=True):
-        super().__init__(*params, wires=wires, do_queue=True)
+        super().__init__(*params, wires=wires, do_queue=do_queue)
 
         pauli_word = params[1]
 
@@ -1580,6 +1634,94 @@ def decomposition(D, wires):
         return [QubitUnitary(np.diag(D), wires=wires)]
 
 
+class QFT(Operation):
+    r"""QFT(wires)
+    Apply a quantum Fourier transform (QFT).
+
+    For the :math:`N`-qubit computational basis state :math:`|m\rangle`, the QFT performs the
+    transformation
+
+    .. math::
+
+        |m\rangle \rightarrow \frac{1}{\sqrt{2^{N}}}\sum_{n=0}^{2^{N} - 1}\omega_{N}^{mn} |n\rangle,
+
+    where :math:`\omega_{N} = e^{\frac{2 \pi i}{2^{N}}}` is the :math:`2^{N}`-th root of unity.
+
+    **Details:**
+
+    * Number of wires: Any (the operation can act on any number of wires)
+    * Number of parameters: 0
+    * Gradient recipe: None
+
+    Args:
+        wires (int or Iterable[Number, str]]): the wire(s) the operation acts on
+
+    **Example**
+
+    The quantum Fourier transform is applied by specifying the corresponding wires:
+
+    .. code-block::
+
+        wires = 3
+
+        @qml.qnode(dev)
+        def circuit_qft(basis_state):
+            qml.BasisState(basis_state, wires=range(wires))
+            qml.QFT(wires=range(wires))
+            return qml.state()
+
+    The inverse quantum Fourier transform is accessed using ``qml.QFT(wires).inv()``.
+    """
+    num_params = 0
+    num_wires = AnyWires
+    par_domain = None
+    grad_method = None
+
+    @property
+    def matrix(self):
+        # Redefine the property here to allow for a custom _matrix signature
+        mat = self._matrix(len(self.wires))
+        if self.inverse:
+            mat = mat.conj()
+        return mat
+
+    @classmethod
+    @functools.lru_cache()
+    def _matrix(cls, num_wires):
+        dimension = 2 ** num_wires
+
+        mat = np.zeros((dimension, dimension), dtype=np.complex128)
+        omega = np.exp(2 * np.pi * 1j / dimension)
+
+        for m in range(dimension):
+            for n in range(dimension):
+                mat[m, n] = omega ** (m * n)
+
+        return mat / np.sqrt(dimension)
+
+    @staticmethod
+    def decomposition(wires):
+        num_wires = len(wires)
+        shifts = [2 * np.pi * 2 ** -i for i in range(2, num_wires + 1)]
+
+        decomp_ops = []
+        for i, wire in enumerate(wires):
+            decomp_ops.append(qml.Hadamard(wire))
+
+            for shift, control_wire in zip(shifts[: len(shifts) - i], wires[i + 1 :]):
+                op = qml.ControlledPhaseShift(shift, wires=[control_wire, wire])
+                decomp_ops.append(op)
+
+        first_half_wires = wires[: num_wires // 2]
+        last_half_wires = wires[-(num_wires // 2) :]
+
+        for wire1, wire2 in zip(first_half_wires, reversed(last_half_wires)):
+            swap = qml.SWAP(wires=[wire1, wire2])
+            decomp_ops.append(swap)
+
+        return decomp_ops
+
+
 # =============================================================================
 # State preparation
 # =============================================================================
@@ -1760,6 +1902,7 @@ def diagonalizing_gates(self):
     "RY",
     "RZ",
     "PhaseShift",
+    "ControlledPhaseShift",
     "Rot",
     "CRX",
     "CRY",
@@ -1772,6 +1915,7 @@ def diagonalizing_gates(self):
     "QubitStateVector",
     "QubitUnitary",
     "DiagonalQubitUnitary",
+    "QFT",
 }