Fall back to op.decompose if op is unsolved in decomposition graph (#8156)

**Context:**
The DecompositionGraph currently errors out completely if any of the
operators is unsolved for, and as a result, with graph enabled, if a
circuit contains a single operator/template that is not yet integrated
with the new decomposition system, the entire thing fails, and the user
is forced to turn off graph mode and use the old decomposition system.
We want to change this behaviour, make it so that the DecompositionGraph
raise a warning instead of an error if certain operators are unsolved
for, and fall back to using op.decomposition for those operators.

**Description of the Change:**
- Downgrade error to a warning when certain operators are unsolved in
the graph.
- Add sensible warning for when the graph failed to find a solution due
to GlobalPhase.
- When the new system is enabled, operators without a decomposition will
be left undecomposed with a warning.

**Benefits:**
- The user can use the new system for the rest of the circuit even if it
contains templates that are not yet integrated with the new graph-based
system.

**Possible Drawbacks:**

**Related GitHub Issues:**
[sc-98390]

---------

Co-authored-by: Yushao Chen (Jerry) <[email protected]>
Co-authored-by: Isaac De Vlugt <[email protected]>
Co-authored-by: Pietropaolo Frisoni <[email protected]>

Author: 4 people

doc/releases/changelog-dev.md

@@ -502,6 +502,13 @@
 * A :class:`~.decomposition.decomposition_graph.DecompGraphSolution` class is added to store the solution of a decomposition graph. An instance of this class is returned from the `solve` method of the :class:`~.decomposition.decomposition_graph.DecompositionGraph`.
   [(#8031)](https://github.com/PennyLaneAI/pennylane/pull/8031)
 
+* With the graph-based decomposition system enabled (:func:`~.decomposition.enable_graph()`), if a decomposition cannot be found for an operator in the circuit, it no longer
+  raises an error. Instead, a warning is raised, and `op.decomposition()` (the current default method for decomposing gates) is
+  used as a fallback, while the rest of the circuit is still decomposed with
+  the new graph-based system. Additionally, a special warning message is
+  raised if the circuit contains a `GlobalPhase`, reminding the user that
+  `GlobalPhase` is not assumed to have a decomposition under the new system.
+  [(#8156)](https://github.com/PennyLaneAI/pennylane/pull/8156)
 <h3>Labs: a place for unified and rapid prototyping of research software 🧪</h3>
 
 * The module `qml.labs.zxopt` has been removed as its functionalities are now available in the

pennylane/decomposition/__init__.py

@@ -66,6 +66,7 @@
     ~DecompositionRule
     ~Resources
     ~CompressedResourceOp
+    ~null_decomp
 
 In the new decomposition system, a decomposition rule must be defined as a quantum function that
 accepts ``(*op.parameters, op.wires, **op.hyperparameters)`` as arguments, where ``op`` is an
@@ -209,6 +210,7 @@ def circuit():
     :toctree: api
 
     ~DecompositionGraph
+    ~DecompGraphSolution
 
 The decomposition graph is a directed graph of operators and decomposition rules. Dijkstra's
 algorithm is used to explore the graph and find the most efficient decomposition of a given
@@ -221,12 +223,12 @@ def circuit():
         operations=[op],
         gate_set={"RZ", "RX", "CNOT", "GlobalPhase"},
     )
-    graph.solve()
+    solution = graph.solve()
 
 .. code-block:: pycon
 
     >>> with qml.queuing.AnnotatedQueue() as q:
-    ...     graph.decomposition(op)(0.5, wires=[0, 1])
+    ...     solution.decomposition(op)(0.5, wires=[0, 1])
     ...
     >>> q.queue
     [RZ(1.5707963267948966, wires=[1]),
@@ -254,7 +256,7 @@ def circuit():
     disable_graph,
     enabled_graph,
 )
-from .decomposition_graph import DecompositionGraph
+from .decomposition_graph import DecompositionGraph, DecompGraphSolution
 from .resources import (
     Resources,
     resource_rep,
@@ -267,6 +269,7 @@ def circuit():
     register_resources,
     register_condition,
     DecompositionRule,
+    null_decomp,
     add_decomps,
     list_decomps,
     has_decomp,

pennylane/decomposition/decomposition_graph.py

@@ -25,6 +25,7 @@
 
 from __future__ import annotations
 
+import warnings
 from collections import defaultdict
 from collections.abc import Iterable
 from dataclasses import dataclass, replace
@@ -488,14 +489,46 @@ def solve(self, num_work_wires: int | None = 0, lazy=True) -> DecompGraphSolutio
         if visitor.unsolved_op_indices:
             unsolved_ops = [self._graph[op_idx] for op_idx in visitor.unsolved_op_indices]
             op_names = {op_node.op.name for op_node in unsolved_ops}
-            raise DecompositionError(
-                f"Decomposition not found for {op_names} to the gate set {set(self._gate_set_weights)}"
+            warnings.warn(
+                f"The graph-based decomposition system is unable to find a decomposition for "
+                f"{op_names} to the target gate set {set(self._gate_set_weights)}. The default "
+                "decomposition (op.decomposition()) for these operators will be used instead.",
+                UserWarning,
             )
         return DecompGraphSolution(visitor, self._all_op_indices, self._op_to_op_nodes)
 
 
 class DecompGraphSolution:
-    """A solution to a decomposition graph."""
+    """A solution to a decomposition graph.
+
+    An instance of this class is returned from :meth:`DecompositionGraph.solve`
+
+    **Example**
+
+    .. code-block:: python
+
+        from pennylane.decomposition import DecompositionGraph
+
+        op = qml.CRX(0.5, wires=[0, 1])
+        graph = DecompositionGraph(
+            operations=[op],
+            gate_set={"RZ", "RX", "CNOT", "GlobalPhase"},
+        )
+        solution = graph.solve()
+
+    >>> with qml.queuing.AnnotatedQueue() as q:
+    ...     solution.decomposition(op)(0.5, wires=[0, 1])
+    >>> q.queue
+    [RZ(1.5707963267948966, wires=[1]),
+     RY(0.25, wires=[1]),
+     CNOT(wires=[0, 1]),
+     RY(-0.25, wires=[1]),
+     CNOT(wires=[0, 1]),
+     RZ(-1.5707963267948966, wires=[1])]
+    >>> solution.resource_estimate(op)
+    <num_gates=10, gate_counts={RZ: 6, CNOT: 2, RX: 2}, weighted_cost=10.0>
+
+    """
 
     def __init__(
         self,

pennylane/decomposition/decomposition_rule.py

@@ -602,5 +602,29 @@ def has_decomp(op_type: type[Operator] | str) -> bool:
 
 @register_resources({})
 def null_decomp(*_, **__):
-    """A decomposition rule that does nothing."""
+    """A decomposition rule that can be assigned to an operator so that the operator decomposes to nothing.
+
+    **Example**
+
+    .. code-block:: python
+
+        from functools import partial
+        import pennylane as qml
+        from pennylane.decomposition import null_decomp
+
+        qml.decomposition.enable_graph()
+
+        @partial(
+            qml.transforms.decompose,
+            gate_set={qml.RZ},
+            fixed_decomps={qml.GlobalPhase: null_decomp}
+        )
+        @qml.qnode(qml.device("default.qubit"))
+        def circuit():
+            qml.Z(0)
+
+    >>> print(qml.draw(circuit)())
+    0: ──RZ(3.14)─┤
+
+    """
     return

pennylane/operation.py

@@ -1446,10 +1446,7 @@ def resource_params(self) -> dict:
         {"num_wires": 2}
 
         """
-        # For most operators, this should just be an empty dictionary, but a default
-        # implementation is intentionally not provided so that each operator class is
-        # forced to explicitly define its resource params.
-        raise NotImplementedError(f"{self.__class__.__name__}.resource_params undefined!")
+        return {}
 
     # pylint: disable=no-self-argument, comparison-with-callable
     @classproperty

pennylane/transforms/decompose.py

@@ -29,7 +29,7 @@
 from pennylane.decomposition.decomposition_graph import DecompGraphSolution
 from pennylane.decomposition.utils import translate_op_alias
 from pennylane.operation import Operator
-from pennylane.ops import Conditional
+from pennylane.ops import Conditional, GlobalPhase
 from pennylane.transforms.core import transform
 
 
@@ -115,7 +115,7 @@ def __init__(
 
             gate_set, stopping_condition = _resolve_gate_set(gate_set, stopping_condition)
             self._gate_set = gate_set
-            self._stopping_condition = stopping_condition
+            self.stopping_condition = stopping_condition
 
         def setup(self) -> None:
             """Setup the environment for the interpreter by pushing a new environment frame."""
@@ -135,34 +135,6 @@ def read(self, var):
             """Extract the value corresponding to a variable."""
             return var.val if isinstance(var, jax.extend.core.Literal) else self._env_map[var]
 
-        def stopping_condition(self, op: Operator) -> bool:
-            """Function to determine whether an operator needs to be decomposed or not.
-
-            Args:
-                op (Operator): Operator to check.
-
-            Returns:
-                bool: Whether ``op`` is valid or needs to be decomposed. ``True`` means
-                    that the operator does not need to be decomposed.
-            """
-
-            # If the new graph-based decomposition is enabled,
-            # we don't rely on the has_decomposition attribute.
-            if enabled_graph():
-                return self._stopping_condition(op)
-
-            if not op.has_decomposition:
-                if not self._stopping_condition(op):
-                    warnings.warn(
-                        f"Operator {op.name} does not define a decomposition and was not "
-                        f"found in the target gate set. To remove this warning, add the operator "
-                        f"name ({op.name}) or type ({type(op)}) to the gate set.",
-                        UserWarning,
-                    )
-                return True
-
-            return self._stopping_condition(op)
-
         def decompose_operation(self, op: Operator):
             """Decompose a PennyLane operation instance if it does not satisfy the
             provided gate set.
@@ -176,7 +148,7 @@ def decompose_operation(self, op: Operator):
             See also: :meth:`~.interpret_operation_eqn`, :meth:`~.interpret_operation`.
             """
 
-            if self._stopping_condition(op):
+            if self.stopping_condition(op):
                 return self.interpret_operation(op)
 
             max_expansion = (
@@ -198,10 +170,10 @@ def decompose_operation(self, op: Operator):
         def _evaluate_jaxpr_decomposition(self, op: Operator):
             """Creates and evaluates a Jaxpr of the plxpr decomposition of an operator."""
 
-            if self._stopping_condition(op):
+            if self.max_expansion is not None and self._current_depth >= self.max_expansion:
                 return self.interpret_operation(op)
 
-            if self.max_expansion is not None and self._current_depth >= self.max_expansion:
+            if self.stopping_condition(op):
                 return self.interpret_operation(op)
 
             if self._decomp_graph_solution and self._decomp_graph_solution.is_solved_for(op):
@@ -763,26 +735,7 @@ def circuit():
 
     gate_set, stopping_condition = _resolve_gate_set(gate_set, stopping_condition)
 
-    def _stopping_condition(op):
-
-        # If the new graph-based decomposition is enabled,
-        # we don't rely on the has_decomposition attribute.
-        if enabled_graph():
-            return stopping_condition(op)
-
-        if not op.has_decomposition:
-            if not stopping_condition(op):
-                warnings.warn(
-                    f"Operator {op.name} does not define a decomposition and was not "
-                    f"found in the target gate set. To remove this warning, add the operator name "
-                    f"({op.name}) or type ({type(op)}) to the gate set.",
-                    UserWarning,
-                )
-            return True
-
-        return stopping_condition(op)
-
-    if all(_stopping_condition(op) for op in tape.operations):
+    if all(stopping_condition(op) for op in tape.operations):
         return (tape,), null_postprocessing
 
     # If the decomposition graph is enabled, we create a DecompositionGraph instance
@@ -805,7 +758,7 @@ def _stopping_condition(op):
             for op in tape.operations
             for final_op in _operator_decomposition_gen(
                 op,
-                _stopping_condition,
+                stopping_condition,
                 max_expansion=max_expansion,
                 num_available_work_wires=num_available_work_wires,
                 graph_solution=decomp_graph_solution,
@@ -839,8 +792,10 @@ def _operator_decomposition_gen(  # pylint: disable=too-many-arguments
     if max_expansion is not None and max_expansion <= current_depth:
         max_depth_reached = True
 
-    # Handle classically controlled operators
-    if isinstance(op, Conditional):
+    if isinstance(op, (Allocate, Deallocate)):
+        yield op
+
+    elif isinstance(op, Conditional):
         if acceptance_function(op.base) or max_depth_reached:
             yield op
         else:
@@ -858,21 +813,37 @@ def _operator_decomposition_gen(  # pylint: disable=too-many-arguments
     elif acceptance_function(op) or max_depth_reached:
         yield op
 
-    elif isinstance(op, (Allocate, Deallocate)):
-        yield op
-
-    elif graph_solution is not None and graph_solution.is_solved_for(op, num_available_work_wires):
+    elif graph_solution and graph_solution.is_solved_for(op, num_available_work_wires):
         op_rule = graph_solution.decomposition(op, num_available_work_wires)
         with queuing.AnnotatedQueue() as decomposed_ops:
             op_rule(*op.parameters, wires=op.wires, **op.hyperparameters)
         decomp = decomposed_ops.queue
-        current_depth += 1
         if num_available_work_wires is not None:
             num_available_work_wires -= op_rule.get_work_wire_spec(**op.resource_params).total
-    else:
+
+    elif enabled_graph() and isinstance(op, GlobalPhase):
+        warnings.warn(
+            "With qml.decomposition.enabled_graph(), GlobalPhase is not assumed to have a "
+            "decomposition. To disable this warning, add GlobalPhase to the gate set, or "
+            "assign a decomposition rule to GlobalPhase via the fixed_decomps keyword "
+            "argument. To make GlobalPhase decompose to nothing, you can import null_decomp "
+            "from pennylane.decomposition, and assign it to GlobalPhase."
+        )
+        yield op
+
+    elif op.has_decomposition:
         decomp = op.decomposition()
-        current_depth += 1
 
+    else:
+        warnings.warn(
+            f"Operator {op.name} does not define a decomposition to the target gate set and was not found in the "
+            f"target gate set. To remove this warning, add the operator name ({op.name}) or "
+            f"type ({type(op)}) to the gate set.",
+            UserWarning,
+        )
+        yield op
+
+    current_depth += 1
     for sub_op in decomp:
         yield from _operator_decomposition_gen(
             sub_op,

tests/capture/transforms/test_capture_decompose.py

@@ -54,8 +54,8 @@ def test_init(self, gate_set, max_expansion):
         assert interpreter.max_expansion == max_expansion
         valid_op = qml.RX(1.5, 0)
         invalid_op = qml.RY(1.5, 0)
-        assert interpreter._stopping_condition(valid_op)
-        assert not interpreter._stopping_condition(invalid_op)
+        assert interpreter.stopping_condition(valid_op)
+        assert not interpreter.stopping_condition(invalid_op)
 
     @pytest.mark.unit
     def test_fixed_alt_decomps_not_available_capture(self):
@@ -73,23 +73,12 @@ def my_cnot(*_, **__):
             DecomposeInterpreter(alt_decomps={qml.CNOT: [my_cnot]})
 
     @pytest.mark.parametrize("op", [qml.RX(1.5, 0), qml.RZ(1.5, 0)])
-    def test_stopping_condition(self, op, recwarn):
+    def test_stopping_condition(self, op):
         """Test that stopping_condition works correctly."""
         # pylint: disable=unnecessary-lambda-assignment
         gate_set = lambda op: op.name == "RX"
         interpreter = DecomposeInterpreter(gate_set=gate_set)
-
-        if gate_set(op):
-            assert interpreter.stopping_condition(op)
-            assert len(recwarn) == 0
-
-        else:
-            if not op.has_decomposition:
-                with pytest.warns(UserWarning, match="does not define a decomposition"):
-                    assert interpreter.stopping_condition(op)
-            else:
-                assert not interpreter.stopping_condition(op)
-                assert len(recwarn) == 0
+        assert interpreter.stopping_condition(op) == gate_set(op)
 
     def test_decompose_simple(self):
         """Test that a simple function can be decomposed correctly."""

tests/capture/transforms/test_capture_graph_decompose.py

@@ -39,10 +39,10 @@ def test_gate_set_contains(self):
         """Tests specifying the target gate set."""
 
         interpreter = DecomposeInterpreter(gate_set={qml.RX, "RZ", "CNOT"})
-        assert interpreter._stopping_condition(qml.RX(1.5, 0))
-        assert interpreter._stopping_condition(qml.RZ(1.5, 0))
-        assert interpreter._stopping_condition(qml.CNOT(wires=[0, 1]))
-        assert not interpreter._stopping_condition(qml.Hadamard(0))
+        assert interpreter.stopping_condition(qml.RX(1.5, 0))
+        assert interpreter.stopping_condition(qml.RZ(1.5, 0))
+        assert interpreter.stopping_condition(qml.CNOT(wires=[0, 1]))
+        assert not interpreter.stopping_condition(qml.Hadamard(0))
 
     @pytest.mark.unit
     def test_callable_gate_set_not_supported(self):

tests/decomposition/test_decomposition_graph.py

@@ -256,7 +256,7 @@ def test_decomposition_not_found(self, _):
 
         op = qml.Hadamard(wires=[0])
         graph = DecompositionGraph(operations=[op], gate_set={"RX", "RY", "GlobalPhase"})
-        with pytest.raises(DecompositionError, match="Decomposition not found for {'Hadamard'}"):
+        with pytest.warns(UserWarning, match="unable to find a decomposition for {'Hadamard'}"):
             graph.solve()
 
     def test_lazy_solve(self, _):