Capture PPR/PPM passes and register MLIR pass names (#8519)

**Context:**
Currently, we can run Catalyst/MLIR passes with the unified compiler
alongside xDSL passes, _if they are represented in the MLIR_. However,
for current MBQC workloads, we want to be able to use them the `capture`
enables, and currently they can't be captured (or converted to MLIR).



**Description of the Change:**
We add dummy versions of the transforms that just raise a
`NotImplemented` error if executed, but are `transform` objects and are
captured in `plxpr`. We register them with the relevant Catalyst pass
name so they can be converted from plxpr to MLIR.


**Benefits:**
We unblock current MBQC work with the PPR/PPM compilation pipeline.

**Possible Drawbacks:**
A more long-term solution to unifying the API for the various
transform/pass types is on the roadmap, and ideally we would use that
instead of manually add the transforms we are interested in to the
`ftqc` module. This is intended to be a temporary patch to unblock
current MBQC work.

---------

Co-authored-by: Joey Carter <[email protected]>

Author: lillian542

doc/releases/changelog-dev.md

@@ -168,6 +168,10 @@
   [(#8486)](https://github.com/PennyLaneAI/pennylane/pull/8486)
   [(#8495)](https://github.com/PennyLaneAI/pennylane/pull/8495)
 
+* The `ftqc` module now includes dummy transforms for several Catalyst/MLIR passes (`to-ppr`, `commute-ppr`, `merge-ppr-ppm`, `pprm-to-mbqc` 
+  and `reduce-t-depth`), to allow them to be captured as primitives in PLxPR and mapped to the MLIR passes in Catalyst. This enables using the passes with the unified compiler and program capture.
+  [(#8519)](https://github.com/PennyLaneAI/pennylane/pull/8519)
+
 * The decompositions for several templates have been updated to use 
   :class:`~.ops.op_math.ChangeOpBasis`, which makes their decompositions more resource efficient
   by eliminating unnecessary controlled operations. The templates include :class:`~.PhaseAdder`, 

pennylane/ftqc/catalyst_pass_aliases.py

@@ -0,0 +1,79 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""This module contains wrapper transforms to provide an API to bind primitives for
+Catalyst passes when using capture and the unified compiler. This is a temporary fix
+to manually add passes relevant for ongoing MBQC work. It can be removed one a more
+general solution for all Catalyst passes is in place."""
+
+from catalyst.from_plxpr import register_transform
+
+from ..transforms.core import transform
+
+
+@transform
+def to_ppr(tape):
+    """A wrapper that allows us to register a primitive that represents the transform during capture.
+    The transform itself is only implemented in Catalyst. This is just to enable capture."""
+    raise NotImplementedError("The to_ppm pass is only implemented when using capture and QJIT.")
+
+
+register_transform(to_ppr, "to-ppr", False)
+
+
+@transform
+def commute_ppr(tape):
+    """A wrapper that allows us to register a primitive that represents the transform during capture.
+    The transform itself is only implemented in Catalyst. This is just to enable capture."""
+    raise NotImplementedError(
+        "The commute_ppr pass is only implemented when using capture and QJIT."
+    )
+
+
+register_transform(commute_ppr, "commute-ppr", False)
+
+
+@transform
+def merge_ppr_ppm(tape):
+    """A wrapper that allows us to register a primitive that represents the transform during capture.
+    The transform itself is only implemented in Catalyst. This is just to enable capture."""
+    raise NotImplementedError(
+        "The merge_ppr_ppm pass is only implemented when using capture and QJIT."
+    )
+
+
+register_transform(merge_ppr_ppm, "merge-ppr-ppm", False)
+
+
+@transform
+def ppm_to_mbqc(tape):
+    """A wrapper that allows us to register a primitive that represents the transform during capture.
+    The transform itself is only implemented in Catalyst. This is just to enable capture."""
+    raise NotImplementedError(
+        "The ppm_to_mbqc pass is only implemented when using capture and QJIT."
+    )
+
+
+register_transform(ppm_to_mbqc, "ppm-to-mbqc", False)
+
+
+@transform
+def reduce_t_depth(tape):
+    """A wrapper that allows us to register a primitive that represents the transform during capture.
+    The transform itself is only implemented in Catalyst. This is just to enable capture."""
+    raise NotImplementedError(
+        "The reduce_t_depth pass is only implemented when using capture and QJIT."
+    )
+
+
+register_transform(reduce_t_depth, "reduce-t-depth", False)

tests/ftqc/test_catalyst_pass_aliases.py

@@ -0,0 +1,101 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Unit tests for wrappers for capturing catalyst passes"""
+
+import pytest
+
+pytest.importorskip("catalyst")
+# pylint: disable=wrong-import-position
+
+import pennylane as qml
+from pennylane.capture import make_plxpr
+from pennylane.ftqc.catalyst_pass_aliases import (
+    commute_ppr,
+    merge_ppr_ppm,
+    ppm_to_mbqc,
+    reduce_t_depth,
+    to_ppr,
+)
+
+pytestmark = pytest.mark.external
+
+
+@pytest.mark.catalyst
+@pytest.mark.usefixtures("enable_disable_plxpr")
+@pytest.mark.parametrize(
+    "pass_fn", [to_ppr, commute_ppr, merge_ppr_ppm, ppm_to_mbqc, reduce_t_depth]
+)
+def test_pass_is_captured(pass_fn):
+
+    @pass_fn
+    @qml.qnode(qml.device("lightning.qubit", wires=3), shots=1000)
+    def circ():
+        qml.H(0)
+        qml.S(0)
+        qml.T(1)
+        qml.CNOT([0, 1])
+        return qml.sample()
+
+    plxpr = make_plxpr(circ)()
+    prim = plxpr.eqns[0].primitive
+    assert prim.name == pass_fn.__name__ + "_transform"
+
+
+@pytest.mark.catalyst
+@pytest.mark.usefixtures("enable_disable_plxpr")
+@pytest.mark.parametrize(
+    "pass_fn, pass_name",
+    [
+        (to_ppr, "to-ppr"),
+        (commute_ppr, "commute-ppr"),
+        (merge_ppr_ppm, "merge-ppr-ppm"),
+        (ppm_to_mbqc, "ppm-to-mbqc"),
+        (reduce_t_depth, "reduce-t-depth"),
+    ],
+)
+def test_converstion_to_mlir(pass_fn, pass_name):
+    """Test that we can generate MLIR from the captured circuit and that the generated MLIR
+    includes the pass name we are mapping to"""
+
+    @qml.qjit(target="mlir")
+    @pass_fn
+    @qml.qnode(qml.device("lightning.qubit", wires=3), shots=1000)
+    def circ():
+        qml.H(0)
+        qml.S(0)
+        qml.T(1)
+        qml.CNOT([0, 1])
+        return qml.sample()
+
+    assert pass_name in circ.mlir
+
+
+@pytest.mark.catalyst
+@pytest.mark.parametrize(
+    "pass_fn", [to_ppr, commute_ppr, merge_ppr_ppm, ppm_to_mbqc, reduce_t_depth]
+)
+def test_pass_without_qjit_raises_error(pass_fn):
+    """Test that trying to apply the transform without QJIT raises an error"""
+
+    @pass_fn
+    @qml.qnode(qml.device("lightning.qubit", wires=3), shots=1000)
+    def circ():
+        qml.H(0)
+        qml.S(0)
+        qml.T(1)
+        qml.CNOT([0, 1])
+        return qml.sample()
+
+    with pytest.raises(NotImplementedError, match="only implemented when using capture and QJIT"):
+        circ()