Implement transform for full single-qubit gate fusion

.github/CHANGELOG.md

@@ -2,6 +2,94 @@
 
 <h3>New features since last release</h3>
 
+* A new quantum function transform has been added to perform full fusion of
+  arbitrary-length sequences of single-qubit gates.
+  [(#1458)](https://github.com/PennyLaneAI/pennylane/pull/1458)
+
+  The `single_qubit_fusion` transform acts on all sequences of
+  single-qubit operations in a quantum function, and converts each
+  sequence to a single `Rot` gate. For example given the circuit:
+
+  ```python
+  def circuit(x, y, z):
+      qml.Hadamard(wires=0)
+      qml.PauliZ(wires=1)
+      qml.RX(x, wires=0)
+      qml.RY(y, wires=1)
+      qml.CZ(wires=[1, 0])
+      qml.T(wires=0)
+      qml.SX(wires=0)
+      qml.Rot(x, y, z, wires=1)
+      qml.Rot(z, y, x, wires=1)
+      return qml.expval(qml.PauliX(wires=0))
+  ```
+
+  ```pycon
+  >>> optimized_circuit = qml.transforms.single_qubit_fusion()(circuit)
+  >>> dev = qml.device('default.qubit', wires=2)
+  >>> qnode = qml.QNode(optimized_circuit, dev)
+  >>> print(qml.draw(qnode)(0.1, 0.2, 0.3))
+   0: ──Rot(3.24, 1.57, 0)──╭Z──Rot(2.36, 1.57, -1.57)────┤ ⟨X⟩
+   1: ──Rot(3.14, 0.2, 0)───╰C──Rot(0.406, 0.382, 0.406)──┤
+  ```
+
+* Two new quantum function transforms have been added to enable the
+  removal of redundant gates in quantum circuits.
+  [(#1455)](https://github.com/PennyLaneAI/pennylane/pull/1455)
+
+  The `cancel_inverses` transform loops through a list of operations,
+  and removes adjacent pairs of operations that cancel out. For example,
+
+  ```python
+  def circuit():
+      qml.Hadamard(wires=0)
+      qml.PauliZ(wires=1)
+      qml.Hadamard(wires=0)
+      qml.T(wires=0)
+      qml.CZ(wires=[0, 1])
+      qml.CZ(wires=[1, 0])
+      return qml.expval(qml.PauliX(wires=0))
+  ```
+
+  ```pycon
+  >>> dev = qml.device('default.qubit', wires=2)
+  >>> qnode = qml.QNode(circuit, dev)
+  >>> print(qml.draw(qnode)())
+   0: ──H──H──T──╭C──╭Z──┤ ⟨X⟩
+   1: ──Z────────╰Z──╰C──┤
+  >>> optimized_circuit = qml.transforms.cancel_inverses(circuit)
+  >>> optimized_qnode = qml.QNode(optimized_circuit, dev)
+  >>> print(qml.draw(optimized_qnode)())
+   0: ──T──┤ ⟨X⟩
+   1: ──Z──┤
+  ```
+
+  The `merge_rotations` transform combines adjacent rotation gates of
+  the same type into a single gate, including controlled rotations.
+
+  ```python
+  def circuit(x, y, z):
+      qml.RX(x, wires=0)
+      qml.RX(x, wires=0)
+      qml.Rot(x, y, z, wires=1)
+      qml.Rot(y, z, x, wires=1)
+      qml.CRY(y, wires=[0, 1])
+      qml.CRY(y + z, wires=[0, 1])
+      return qml.expval(qml.PauliX(wires=0))
+  ```
+
+  ```pycon
+  >>> qnode = qml.QNode(circuit, dev)
+  >>> print(qml.draw(qnode)(0.1, 0.2, 0.3))
+   0: ──RX(0.1)─────────────RX(0.1)─────────────╭C────────╭C────────┤ ⟨X⟩
+   1: ──Rot(0.1, 0.2, 0.3)──Rot(0.2, 0.3, 0.1)──╰RY(0.2)──╰RY(0.5)──┤
+  >>> optimized_circuit = qml.transforms.merge_rotations()(circuit)
+  >>> optimized_qnode = qml.QNode(optimized_circuit, dev)
+  >>> print(qml.draw(optimized_qnode)(0.1, 0.2, 0.3))
+   0: ──RX(0.2)───────────────────╭C────────┤ ⟨X⟩
+   1: ──Rot(0.409, 0.485, 0.306)──╰RY(0.7)──┤
+  ```
+
 * A decomposition has been added to ``QubitUnitary`` that makes the
   single-qubit case fully differentiable in all interfaces. Furthermore,
   a quantum function transform, ``unitary_to_rot()``, has been added to decompose all

pennylane/math/single_dispatch.py

@@ -117,12 +117,14 @@ def _take_autograd(tensor, indices, axis=None):
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "arcsin"] = "tensorflow.math"
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "arccos"] = "tensorflow.math"
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "arctan"] = "tensorflow.math"
+ar.autoray._SUBMODULE_ALIASES["tensorflow", "arctan2"] = "tensorflow.math"
 ar.autoray._SUBMODULE_ALIASES["tensorflow", "diag"] = "tensorflow.linalg"
 
 
 ar.autoray._FUNC_ALIASES["tensorflow", "arcsin"] = "asin"
 ar.autoray._FUNC_ALIASES["tensorflow", "arccos"] = "acos"
 ar.autoray._FUNC_ALIASES["tensorflow", "arctan"] = "atan"
+ar.autoray._FUNC_ALIASES["tensorflow", "arctan2"] = "atan2"
 ar.autoray._FUNC_ALIASES["tensorflow", "diag"] = "diag"
 
 
@@ -243,6 +245,9 @@ def _scatter_element_add_tf(tensor, index, value):
     ),
 )
 
+ar.autoray._SUBMODULE_ALIASES["torch", "arctan2"] = "torch"
+ar.autoray._FUNC_ALIASES["torch", "arctan2"] = "atan2"
+
 
 def _take_torch(tensor, indices, axis=None):
     """Torch implementation of np.take"""

pennylane/operation.py

@@ -539,6 +539,61 @@ def grad_method(self):
         s_1]=[-1/2, 1, -\pi/2]` is assumed for every parameter.
     """
 
+    # Attributes for compilation transforms
+    is_self_inverse = None
+    """bool or None: ``True`` if the operation is its own inverse.
+
+    If ``None``, all instances of the given operation will be ignored during
+    compilation transforms involving inverse cancellation.
+    """
+
+    is_symmetric_over_all_wires = None
+    """bool or None: ``True`` if the operation is the same if you exchange the order
+    of wires.
+
+    For example, ``qml.CZ(wires=[0, 1])`` has the same effect as ``qml.CZ(wires=[1,
+    0])`` due to symmetry of the operation.
+
+    If ``None``, all instances of the operation will be ignored during
+    compilation transforms that check for wire symmetry.
+    """
+
+    is_symmetric_over_control_wires = None
+    """bool or None: ``True`` if the operation is the same if you exchange the order
+    of all but the last wire.
+
+    For example, ``qml.Toffoli(wires=[0, 1, 2])`` has the same effect as
+    ``qml.Toffoli(wires=[1, 0, 2])``, but neither are the same as
+    ``qml.Toffoli(wires=[0, 2, 1])``.
+
+    If ``None``, all instances of the operation will be ignored during
+    compilation transforms that check for control-wire symmetry.
+    """
+
+    is_composable_rotation = None
+    """bool or None: ``True`` if composing multiple copies of the operation
+    results in an addition (or alternative accumulation) of parameters.
+
+    For example, ``qml.RZ`` is a composable rotation. Applying ``qml.RZ(0.1,
+    wires=0)`` followed by ``qml.RZ(0.2, wires=0)`` is equivalent to performing
+    a single rotation ``qml.RZ(0.3, wires=0)``.
+
+    If set to ``None``, the operation will be ignored during compilation
+    transforms that merge adjacent rotations.
+    """
+
+    @property
+    def single_qubit_rot_angles(self):
+        """The parameters required to implement a single-qubit gate as an
+        equivalent ``Rot`` gate, up to a global phase.
+
+        Returns:
+            tuple[float, float, float]: A list of values :math:`[\phi, \theta, \omega]`
+            such that :math:`RZ(\omega) RY(\theta) RZ(\phi)` is equivalent to the
+            original operation.
+        """
+        raise NotImplementedError
+
     def get_parameter_shift(self, idx, shift=np.pi / 2):
         """Multiplier and shift for the given parameter, based on its gradient recipe.