globalphase decomposes to nothing

doc/releases/changelog-dev.md

@@ -79,6 +79,9 @@
 * Simplified the logic for re-arranging states before returning.
   [(#4817)](https://github.com/PennyLaneAI/pennylane/pull/4817)
 
+* `GlobalPhase` now decomposes to nothing, in case devices do not support global phases.
+  [(#4855)](https://github.com/PennyLaneAI/pennylane/pull/4855)
+
 <h3>Breaking changes 💔</h3>
 
 * Moved `qml.cond` and the `Conditional` operation from the `transforms` folder to the `ops/op_math` folder.

pennylane/ops/identity.py

@@ -328,6 +328,38 @@ def compute_diagonalizing_gates(
         """
         return []
 
+    @staticmethod
+    def compute_decomposition(phi, wires=None):  # pylint:disable=arguments-differ,unused-argument
+        r"""Representation of the operator as a product of other operators (static method).
+
+        .. note::
+
+            The ``GlobalPhase`` operation decomposes to an empty list of operations.
+            Support for global phase
+            was added in v0.33 and was ignored in earlier versions of PennyLane. Setting
+            global phase to decompose to nothing allows existing devices to maintain
+            current support for operations which now have ``GlobalPhase`` in the
+            decomposition pipeline.
+
+        .. math:: O = O_1 O_2 \dots O_n.
+
+        .. seealso:: :meth:`~.GlobalPhase.decomposition`.
+
+        Args:
+            phi (TensorLike): the global phase
+            wires (Iterable[Any] or Any): unused argument - the operator is applied to all wires
+
+        Returns:
+            list[Operator]: decomposition into lower level operations
+
+        **Example:**
+
+        >>> qml.GlobalPhase.compute_decomposition(1.23)
+        []
+
+        """
+        return []
+
     def matrix(self, wire_order=None):
         n_wires = len(wire_order) if wire_order else len(self.wires)
         return self.compute_matrix(self.data[0], n_wires=n_wires)

pennylane/ops/op_math/controlled.py

@@ -594,6 +594,13 @@ def _decompose_no_control_values(op: "operation.Operator") -> List["operation.Op
         return None
 
     base_decomp = op.base.decomposition()
+    if len(base_decomp) == 0 and isinstance(op.base, qml.GlobalPhase):
+        warnings.warn(
+            "Controlled-GlobalPhase currently decomposes to nothing, and this will likely "
+            "produce incorrect results. Consider implementing your circuit with a different set "
+            "of operations, or use a device that natively supports GlobalPhase.",
+            UserWarning,
+        )
 
     return [Controlled(newop, op.control_wires, work_wires=op.work_wires) for newop in base_decomp]
 

tests/ops/op_math/test_controlled.py

@@ -843,6 +843,14 @@ def test_differentiable_one_qubit_special_unitary(self):
         decomp_mat = qml.matrix(op.decomposition, wire_order=op.wires)()
         assert qml.math.allclose(op.matrix(), decomp_mat)
 
+    def test_global_phase_decomp_raises_warning(self):
+        """Test that ctrl(GlobalPhase).decomposition() raises a warning."""
+        op = qml.ctrl(qml.GlobalPhase(1.23), control=[0])
+        with pytest.warns(
+            UserWarning, match="Controlled-GlobalPhase currently decomposes to nothing"
+        ):
+            assert op.decomposition() == []
+
 
 @pytest.mark.parametrize("test_expand", (False, True))
 class TestDecomposition:

tests/ops/qubit/test_parametric_ops.py

@@ -4522,6 +4522,13 @@ def test_global_phase_compute_sparse_matrix(phi, n_wires):
     assert np.allclose(sparse_matrix.todense(), expected.todense())
 
 
+def test_decomposition():
+    """Test the decomposition of the GlobalPhase operation."""
+
+    assert qml.GlobalPhase.compute_decomposition(1.23) == []
+    assert qml.GlobalPhase(1.23).decomposition() == []
+
+
 control_data = [
     (qml.Rot(1, 2, 3, wires=0), Wires([])),
     (qml.RX(1.23, wires=0), Wires([])),