Add adjoint lowering pattern for PPR op (#2227)

**Context:**
When a user places a PPR op in an adjoint qfunc (see #2145 ), the
`--adjoint-lowering` pass will not correctly distribute the adjoint into
the region onto PPRs, because the pass does not recognize PPRs.

**Description of the Change:**
Add pattern for PPR ops in adjoint lowering pass.

**Benefits:**
Correct behavior

**Possible Drawbacks:**
None

Author: paul0403

doc/releases/changelog-dev.md

@@ -50,6 +50,9 @@
 * Dynamically allocated wires can now be passed into control flow and subroutines.
   [(#2130)](https://github.com/PennyLaneAI/catalyst/pull/2130)
 
+* The `--adjoint-lowering` pass can now handle PPR operations.
+  [(#2227)](https://github.com/PennyLaneAI/catalyst/pull/2227)
+
 <h3>Breaking changes 💔</h3>
 
 * The plxpr transform `pl_map_wires` has been removed along with its test.

mlir/lib/Quantum/Transforms/AdjointPatterns.cpp

@@ -34,6 +34,7 @@
 #include "mlir/Transforms/DialectConversion.h"
 
 #include "Catalyst/IR/CatalystOps.h"
+#include "QEC/IR/QECDialect.h"
 #include "Quantum/IR/QuantumInterfaces.h"
 #include "Quantum/IR/QuantumOps.h"
 #include "Quantum/Transforms/Patterns.h"
@@ -116,6 +117,9 @@ class AdjointGenerator {
             else if (auto gate = dyn_cast<quantum::QuantumGate>(op)) {
                 visitOperation(gate, builder);
             }
+            else if (auto ppr = dyn_cast<qec::PPRotationOp>(op)) {
+                visitOperation(ppr, builder);
+            }
             else if (auto adjointOp = dyn_cast<quantum::AdjointOp>(&op)) {
                 BlockArgument regionArg = adjointOp.getRegion().getArgument(0);
                 Value result = adjointOp.getResult();
@@ -273,6 +277,22 @@ class AdjointGenerator {
         }
     }
 
+    void visitOperation(qec::PPRotationOp ppr, OpBuilder &builder)
+    {
+        for (const auto &[qubitResult, qubitOperand] :
+             llvm::zip(ppr.getOutQubits(), ppr.getInQubits())) {
+            remappedValues.map(qubitOperand, remappedValues.lookup(qubitResult));
+        }
+
+        auto clone = cast<qec::PPRotationOp>(builder.clone(*ppr, remappedValues));
+        clone.setRotationKind(ppr.getRotationKind() * (-1));
+
+        for (const auto &[qubitResult, qubitOperand] :
+             llvm::zip(clone.getOutQubits(), ppr.getInQubits())) {
+            remappedValues.map(qubitOperand, qubitResult);
+        }
+    }
+
     void visitOperation(func::CallOp callOp, OpBuilder &builder)
     {
         // Get the the original function

mlir/lib/Quantum/Utils/QuantumSplitting.cpp

@@ -22,6 +22,7 @@
 #include "mlir/Transforms/DialectConversion.h"
 
 #include "Catalyst/IR/CatalystOps.h"
+#include "QEC/IR/QECDialect.h"
 #include "Quantum/IR/QuantumOps.h"
 #include "Quantum/Utils/QuantumSplitting.h"
 
@@ -204,6 +205,9 @@ void AugmentedCircuitGenerator::generate(Region &region, OpBuilder &builder)
         else if (isa<QuantumDialect>(op.getDialect())) {
             // Any quantum op other than a parametrized gate/insert/extract is ignored.
         }
+        else if (isa<qec::PPRotationOp>(op)) {
+            // PPRs are ignored
+        }
         else if (isClassicalSCFOp(op)) {
             // Purely classical SCF ops should be treated as any other purely classical op, but
             // quantum SCF ops need to be recursively visited.

mlir/test/QEC/AdjointTest.mlir

@@ -0,0 +1,33 @@
+// 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.
+
+// RUN: quantum-opt --adjoint-lowering --split-input-file -verify-diagnostics %s | FileCheck %s
+
+// CHECK-LABEL:      @workflow
+func.func private @workflow(%r: !quantum.reg) -> !quantum.reg attributes {} {
+  // CHECK-NOT: quantum.adjoint
+  %r_out = quantum.adjoint(%r) : !quantum.reg {
+  ^bb0(%arg0: !quantum.reg):
+    %0 = quantum.extract %arg0[0] : !quantum.reg -> !quantum.bit
+
+    // CHECK: qec.ppr ["Y"](4)
+    // CHECK: qec.ppr ["X"](-2)
+    %1 = qec.ppr ["X"](2) %0 : !quantum.bit
+    %2 = qec.ppr ["Y"](-4) %1 : !quantum.bit
+
+    %3 = quantum.insert %arg0[0], %2 : !quantum.reg, !quantum.bit
+    quantum.yield %3 : !quantum.reg
+  }
+  return %r_out : !quantum.reg
+}