Support commuting P(pi/2) past non-Clifford PPR (#1966)

**Context:**
At the moment, only pi/4 Cliffords can be commuted past non-Clifford.
With this PR, pi/2 Cliffords should also be able to be commuted.

**Description of the Change:**
The main change is implemented in
`PauliStringWrapper::computeCommutationRulesWith`. Here, we keep
returning `PP'i` for a pi/4 Clifford, but we now return `-P'` for a pi/2
Clifford.
The other main change needed is to update the definition of `isClifford`
in QECDialect.td. Now, a Clifford can also have a rotation of pi/2.

**Benefits:**
pi/2 Cliffords can now be commuted past non-Clifford.

**Possible Drawbacks:**
I have only added 2 anti-conmute tests. More tests may be needed.

**Related GitHub Issues:**
close #1713

---------

Co-authored-by: Sengthai Heng <[email protected]>

Author: rturrado

doc/releases/changelog-dev.md

@@ -31,6 +31,9 @@
   %0 = transform.apply_registered_pass "some-pass" with options = {"an-option" = true, "maxValue" = 1 : i64, "multi-word-option" = 1 : i64}
   ```
 
+*  `Commuting Clifford Pauli Product Rotation (PPR) operations, past non-Clifford PPRs, now supports P(π/2) Cliffords in addition to P(π/4)`
+   [(#1966)](https://github.com/PennyLaneAI/catalyst/pull/1966)
+
 <h3>Breaking changes 💔</h3>
 
 * The JAX version used by Catalyst is updated to 0.6.2.

frontend/catalyst/passes/builtin_passes.py

@@ -530,7 +530,7 @@ def to_ppr(qnode):
 
     .. note::
 
-        The circuit that generated from this pass are currently
+        The circuits that generated from this pass are currently
         only not executable in any backend. This pass is only for analysis
         and potential future execution when a suitable backend is available.
 

mlir/include/QEC/IR/QECDialect.td

@@ -323,13 +323,24 @@ def PPRotationOp : QEC_Op<"ppr", [QECOpInterface, AttrSizedOperandSegments]> {
     let hasVerifier = 1;
 
     code extraBaseClassDeclaration = [{
-        bool isNonClifford(){
+        bool hasPiOverTwoRotation(){
             int16_t rotationKind = static_cast<int16_t>(getRotationKind());
-            return rotationKind == 8 || rotationKind == -8;  // π/8 rotations are non-Clifford
+            return rotationKind == 2 || rotationKind == -2;
         };
-        bool isClifford(){
+        bool hasPiOverFourRotation(){
             int16_t rotationKind = static_cast<int16_t>(getRotationKind());
-            return rotationKind == 4 || rotationKind == -4;  // π/4 rotations are Clifford
+            return rotationKind == 4 || rotationKind == -4;
+        };
+        bool hasPiOverEightRotation(){
+            int16_t rotationKind = static_cast<int16_t>(getRotationKind());
+            return rotationKind == 8 || rotationKind == -8;
+        };
+
+        bool isNonClifford(){
+            return hasPiOverEightRotation();  // π/8 rotations are non-Clifford
+        };
+        bool isClifford(){
+            return hasPiOverTwoRotation() || hasPiOverFourRotation();  // π/2 and π/4 rotations are Clifford
         };
     }];
     let extraClassDeclaration = extraBaseClassDeclaration;

mlir/include/QEC/Utils/PauliStringWrapper.h

@@ -14,9 +14,10 @@
 
 #pragma once
 
+#include "llvm/ADT/SetVector.h"
+
 #include "QEC/IR/QECDialect.h"
 #include "QEC/Transforms/Patterns.h"
-#include "llvm/ADT/SetVector.h"
 
 using namespace mlir;
 
@@ -82,8 +83,11 @@ struct PauliStringWrapper {
 
     // Commutation Rules
     // P is Clifford, P' is non-Clifford
+    //   P can have a π/2 or π/4 rotation
     // if P commutes with P' then PP' = P'P
-    // if P anti-commutes with P' then PP' = -iPP' P
+    // if P anti-commutes with P' then
+    //   if P has a π/2 rotation then PP' = -P'P
+    //   if P has a π/4 rotation then PP' = -iPP'P
     // In here, P and P' are lhs and rhs, respectively.
     PauliStringWrapper computeCommutationRulesWith(const PauliStringWrapper &rhs) const;
 };
@@ -95,15 +99,15 @@ struct PauliStringWrapper {
 using PauliWordPair = std::pair<PauliStringWrapper, PauliStringWrapper>;
 
 /**
- * @brief Expland the op's operands to the set of operands.
+ * @brief Expand the op's operands to the set of operands.
  *        - Initialize the new pauliWord with "I" for each qubit.
  *        - Find location of inOutOperands in set of operands
  *        - Assign the inOutOperands' pauli word to new pauliWord in that location
  *        e.g: qubits = {q0, q1, q2}, inQubitOut = [q1, q2], op.getPauliProduct() = ["X", "Y"]
  *        -> ["I", "X", "Y"]
  *
  * @tparam T either mlir::Operation::operand_range or mlir::Operation::result_range
- * @param qubits set of combination of qubit operands
+ * @param operands set of combination of qubit operands
  * @param inOutOperands either value from.inQubits or .outQubits from op
  * @param op QECOpInterface
  * @return PauliWord of the expanded pauliWord
@@ -151,7 +155,7 @@ SmallVector<Value> replaceValueWithOperands(const PauliStringWrapper &lhsPauliWr
 /**
  * @brief Update the pauliWord of the right hand side operation.
  *
- * @param rhsOp QECOpInterface of the right hand side
+ * @param op QECOpInterface of the right hand side
  * @param newPauliWord PauliWord of the new pauliWord
  * @param rewriter PatternRewriter
  */

mlir/lib/QEC/Transforms/CommutePPR.cpp

@@ -111,7 +111,7 @@ void moveCliffordPastNonClifford(const PauliStringWrapper &lhsPauli,
         updatePauliWordSign(rhs, rhsPauli.isNegative(), rewriter);
     }
 
-    // Fullfill Operands of RHS
+    // Fulfill Operands of RHS
     SmallVector<Value> newRHSOperands = replaceValueWithOperands(lhsPauli, rhsPauli);
 
     // Remove the Identity gate in the Pauli product

mlir/lib/QEC/Transforms/DecomposeCliffordPPR.cpp

@@ -18,12 +18,11 @@
 #include <mlir/IR/Builders.h>
 #include <mlir/IR/Value.h>
 
-#include "Quantum/IR/QuantumOps.h"
-
 #include "QEC/IR/QECDialect.h"
 #include "QEC/Transforms/PPRDecomposeUtils.h"
 #include "QEC/Transforms/Patterns.h"
 #include "QEC/Utils/PauliStringWrapper.h"
+#include "Quantum/IR/QuantumOps.h"
 
 using namespace mlir;
 using namespace catalyst::qec;
@@ -105,7 +104,7 @@ struct DecomposeCliffordPPR : public OpRewritePattern<PPRotationOp> {
 
     LogicalResult matchAndRewrite(PPRotationOp op, PatternRewriter &rewriter) const override
     {
-        if (op.isClifford()) {
+        if (op.hasPiOverFourRotation()) {
             decompose_pi_over_four_flattening(avoidPauliYMeasure, op, op.getCondition(), rewriter);
             return success();
         }

mlir/lib/QEC/Utils/PauliStringWrapper.cpp

@@ -16,9 +16,8 @@
 #include <stim/stabilizers/flex_pauli_string.h>
 #include <stim/stabilizers/pauli_string.h>
 
-#include "Quantum/IR/QuantumOps.h" // for quantum::AllocQubitOp
-
 #include "QEC/Utils/PauliStringWrapper.h"
+#include "Quantum/IR/QuantumOps.h" // for quantum::AllocQubitOp
 
 namespace catalyst {
 namespace qec {
@@ -79,12 +78,21 @@ bool PauliStringWrapper::commutes(const PauliStringWrapper &other) const
 PauliStringWrapper
 PauliStringWrapper::computeCommutationRulesWith(const PauliStringWrapper &rhs) const
 {
-    // P * P' * i
-    stim::FlexPauliString result =
-        (*this->pauliString) * (*rhs.pauliString) * stim::FlexPauliString::from_text("i");
-
+    stim::FlexPauliString result = *rhs.pauliString;
+    assert(llvm::isa<PPRotationOp>(this->op) && "Clifford Operation is not PPRotationOp");
+    auto this_op = llvm::cast<PPRotationOp>(this->op);
+    if (this_op.hasPiOverTwoRotation()) {
+        // -P'
+        result.value.sign = !result.value.sign;
+    }
+    else if (this_op.hasPiOverFourRotation()) {
+        // P * P' * i
+        result = (*this->pauliString) * result * stim::FlexPauliString::from_text("i");
+    }
+    else {
+        llvm_unreachable("Clifford rotation should be π/2 or π/4");
+    }
     assert(!result.imag && "Resulting Pauli string should be real");
-
     return PauliStringWrapper(std::move(result));
 }
 

mlir/test/QEC/CommutePPR.mlir

@@ -120,7 +120,7 @@ func.func @test_anticommute_5(%q1 : !quantum.bit, %q2 : !quantum.bit){
 
 func.func @test_anticommute_6(%q1 : !quantum.bit, %q2 : !quantum.bit){
 
-    // XY commuts with ZZ
+    // XY commutes with ZZ
 
     // XY(4) * ZZ(8) * ZY(8)
     // -> ZZ(8) * XY(4) * ZY(8)
@@ -188,6 +188,54 @@ func.func @test_anticommute_9(%q1 : !quantum.bit, %q2 : !quantum.bit, %q3 : !qua
 
 // -----
 
+func.func @test_anticommute_10(%q1 : !quantum.bit){
+
+    // Pauli rule:
+    // YZ = -ZY
+
+    // Y(2) * Z(8) * Y(2) * Z(8)
+    // -> Z(-8) * Y(2) * Y(2) * Z(8)
+    // -> Z(-8) * Y(2) * Z(-8) * Y(2)
+    // -> Z(-8) * Z(8) * Y(2) * Y(2)
+
+    // CHECK: [[q1_0:%.+]] = qec.ppr ["Z"](-8) %arg0
+    // CHECK: [[q1_1:%.+]] = qec.ppr ["Z"](8) [[q1_0]]
+    // CHECK: [[q1_2:%.+]] = qec.ppr ["Y"](2) [[q1_1]]
+    // CHECK: [[q1_3:%.+]] = qec.ppr ["Y"](2) [[q1_2]]
+    %0 = qec.ppr ["Y"](2) %q1 : !quantum.bit
+    %1 = qec.ppr ["Z"](8) %0 : !quantum.bit
+    %2 = qec.ppr ["Y"](2) %1 : !quantum.bit
+    %3 = qec.ppr ["Z"](8) %2 : !quantum.bit
+    func.return
+}
+
+// -----
+
+func.func @test_anticommute_11(%q1 : !quantum.bit, %q2 : !quantum.bit, %q3 : !quantum.bit){
+
+    // Pauli rules:
+    //
+    // XZ = -ZX
+    //
+    // P and P' commute if there is an even number of anti-commuting single-qubit pairs.
+    // Otherwise, they anti-commute.
+
+
+    // XYZ(2) * XZY(8) * ZYZ(8)
+    // -> XZY(8) * XYZ(2) * ZYZ(8)   // XYZ(2) and XZY(8) commute (XX commute, YZ and ZY anti-commute)
+    // -> XZY(8) * ZYZ(-8) * XYZ(2)  // XYZ(2) and ZYZ(8) anti-commute (XZ anti-commutes, YY and ZZ commute)
+
+    // CHECK: [[q1_0:%.+]]:3 = qec.ppr ["X", "Z", "Y"](8) %arg0, %arg1, %arg2
+    // CHECK: [[q1_1:%.+]]:3 = qec.ppr ["Z", "Y", "Z"](-8) [[q1_0]]#0, [[q1_0]]#1, [[q1_0]]#2
+    // CHECK: [[q1_2:%.+]]:3 = qec.ppr ["X", "Y", "Z"](2) [[q1_1]]#0, [[q1_1]]#1, [[q1_1]]#2
+    %0:3 = qec.ppr ["X", "Y", "Z"](2) %q1, %q2, %q3 : !quantum.bit, !quantum.bit, !quantum.bit
+    %1:3 = qec.ppr ["X", "Z", "Y"](8) %0#0, %0#1, %0#2 : !quantum.bit, !quantum.bit, !quantum.bit
+    %2:3 = qec.ppr ["Z", "Y", "Z"](8) %1#0, %1#1, %1#2 : !quantum.bit, !quantum.bit, !quantum.bit
+    func.return
+}
+
+// -----
+
 func.func public @circuit_first_minus(%q0: !quantum.bit, %q1: !quantum.bit) {
 
     // CHECK: qec.ppr ["Y"](-8)

mlir/test/QEC/MergePPRIntoPPM.mlir

@@ -17,9 +17,9 @@
 
 func.func public @merge_ppr_ppm_test_1(%q1: !quantum.bit) -> tensor<i1> {
 
-    // CHECK-NOT:   qec.ppr["X"](4)
-    // CHECK:       qec.ppm ["X"] %
-    // CHECK-NOT:   qec.ppr["X"](4)
+    // CHECK-NOT: qec.ppr ["X"]
+    // CHECK:     qec.ppm ["X"] %
+    // CHECK-NOT: qec.ppr ["X"]
     %0 = qec.ppr ["X"](4) %q1: !quantum.bit
     %m, %out_qubits = qec.ppm ["X"] %0 : !quantum.bit
     %from_elements = tensor.from_elements %m : tensor<i1>
@@ -28,9 +28,8 @@ func.func public @merge_ppr_ppm_test_1(%q1: !quantum.bit) -> tensor<i1> {
 
 func.func public @merge_ppr_ppm_test_2(%q1: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
 
-    // CHECK-NOT:   qec.ppr["X"](4)
-    // CHECK:       qec.ppm ["Z"](-1) %
-    // CHECK-NOT:   qec.ppr["X"](4)
+    // CHECK: qec.ppm ["Z"](-1) %
+    // CHECK: qec.ppr ["X"](4)
     %0 = qec.ppr ["X"](4) %q1: !quantum.bit
     %m, %out_qubits = qec.ppm ["Y"] %0 : !quantum.bit
     %from_elements = tensor.from_elements %m : tensor<i1>
@@ -39,9 +38,8 @@ func.func public @merge_ppr_ppm_test_2(%q1: !quantum.bit) -> (tensor<i1>, !quant
 
 func.func public @merge_ppr_ppm_test_3(%q1: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
 
-    // CHECK-NOT:   qec.ppr["X"](4)
-    // CHECK:       qec.ppm ["Y"] %
-    // CHECK-NOT:   qec.ppr["X"](4)
+    // CHECK: qec.ppm ["Y"] %
+    // CHECK: qec.ppr ["X"](-4)
     %0 = qec.ppr ["X"](-4) %q1: !quantum.bit
     %m, %out_qubits = qec.ppm ["Z"](-1) %0 : !quantum.bit
     %from_elements = tensor.from_elements %m : tensor<i1>
@@ -50,12 +48,12 @@ func.func public @merge_ppr_ppm_test_3(%q1: !quantum.bit) -> (tensor<i1>, !quant
 
 func.func public @merge_ppr_ppm_test_4(%q1: !quantum.bit, %q2: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
 
-    // CHECK: [[q0:%.+]] = qec.ppr ["X"](8) %arg0 : !quantum.bit
+    // CHECK:     [[q0:%.+]] = qec.ppr ["X"](8) %arg0 : !quantum.bit
     // CHECK-NOT: ["X"](4)
-    // CHECK: [[m1:%.+]], [[o1:%.+]]:2 = qec.ppm ["X", "X"] %arg1, [[q0]]
+    // CHECK:     [[m1:%.+]], [[o1:%.+]]:2 = qec.ppm ["X", "X"] %arg1, [[q0]]
     // CHECK-NOT: ["X"](4)
-    // CHECK: %from_elements = tensor.from_elements [[m1]] : tensor<i1>
-    // CHECK: return %from_elements, [[o1]]#1 : tensor<i1>, !quantum.bit
+    // CHECK:     %from_elements = tensor.from_elements [[m1]] : tensor<i1>
+    // CHECK:     return %from_elements, [[o1]]#1 : tensor<i1>, !quantum.bit
     %0 = qec.ppr ["X"](8) %q1: !quantum.bit
     %1 = qec.ppr ["X"](4) %q2: !quantum.bit
     %m, %out_qubits:2 = qec.ppm ["X", "X"] %0, %1 : !quantum.bit, !quantum.bit
@@ -65,12 +63,12 @@ func.func public @merge_ppr_ppm_test_4(%q1: !quantum.bit, %q2: !quantum.bit) ->
 
 func.func public @merge_ppr_ppm_test_5(%q1: !quantum.bit, %q2: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
 
-    // CHECK:       [[q0:%.+]] = qec.ppr ["X"](8) %arg0 : !quantum.bit
-    // CHECK-NOT:   qec.ppr ["Y"](4)
-    // CHECK:       [[m1:%.+]], [[o1:%.+]]:2 = qec.ppm ["Z", "X"] %arg1, [[q0]]
-    // CHECK-NOT:   qec.ppr ["Y"](4)
-    // CHECK:       %from_elements = tensor.from_elements [[m1]] : tensor<i1>
-    // CHECK:       return %from_elements, [[o1]]#1 : tensor<i1>, !quantum.bit
+    // CHECK:     [[q0:%.+]] = qec.ppr ["X"](8) %arg0 : !quantum.bit
+    // CHECK-NOT: qec.ppr ["Y"](4)
+    // CHECK:     [[m1:%.+]], [[o1:%.+]]:2 = qec.ppm ["Z", "X"] %arg1, [[q0]]
+    // CHECK-NOT: qec.ppr ["Y"](4)
+    // CHECK:     %from_elements = tensor.from_elements [[m1]] : tensor<i1>
+    // CHECK:     return %from_elements, [[o1]]#1 : tensor<i1>, !quantum.bit
     %0 = qec.ppr ["X"](8) %q1: !quantum.bit
     %1 = qec.ppr ["Y"](4) %q2: !quantum.bit
     %m, %out_qubits:2 = qec.ppm ["X", "X"] %0, %1 : !quantum.bit, !quantum.bit
@@ -92,6 +90,37 @@ func.func public @merge_ppr_ppm_test_6(%q1: !quantum.bit, %q2: !quantum.bit) ->
     return %from_elements, %out_qubits#0 : tensor<i1>, !quantum.bit
 }
 
+func.func public @merge_ppr_ppm_test_7(%q1: !quantum.bit) -> tensor<i1> {
+
+    // CHECK-NOT: qec.ppr ["X"]
+    // CHECK:     qec.ppm ["X"] %
+    // CHECK-NOT: qec.ppr ["X"]
+    %0 = qec.ppr ["X"](2) %q1: !quantum.bit
+    %m, %out_qubits = qec.ppm ["X"] %0 : !quantum.bit
+    %from_elements = tensor.from_elements %m : tensor<i1>
+    return %from_elements : tensor<i1>
+}
+
+func.func public @merge_ppr_ppm_test_8(%q1: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
+
+    // CHECK: qec.ppm ["Y"](-1) %
+    // CHECK: qec.ppr ["X"](2)
+    %0 = qec.ppr ["X"](2) %q1: !quantum.bit
+    %m, %out_qubits = qec.ppm ["Y"] %0 : !quantum.bit
+    %from_elements = tensor.from_elements %m : tensor<i1>
+    return %from_elements, %out_qubits : tensor<i1>, !quantum.bit
+}
+
+func.func public @merge_ppr_ppm_test_9(%q1: !quantum.bit) -> (tensor<i1>, !quantum.bit) {
+
+    // CHECK: qec.ppm ["Z"] %
+    // CHECK: qec.ppr ["X"](-2)
+    %0 = qec.ppr ["X"](-2) %q1: !quantum.bit
+    %m, %out_qubits = qec.ppm ["Z"](-1) %0 : !quantum.bit
+    %from_elements = tensor.from_elements %m : tensor<i1>
+    return %from_elements, %out_qubits : tensor<i1>, !quantum.bit
+}
+
 func.func public @game_of_surface_code(%arg0: !quantum.bit, %arg1: !quantum.bit, %arg2: !quantum.bit, %arg3: !quantum.bit) {
 
     // q1
@@ -102,10 +131,10 @@ func.func public @game_of_surface_code(%arg0: !quantum.bit, %arg1: !quantum.bit,
     // CHECK: [[q2:%.+]]:2 = qec.ppr ["Y", "X"](8) %arg2, %arg1
 
     // q3, q2, q4, q1
-    // CHECK: [[q3:%.+]]:4 = qec.ppr ["Z", "Z", "Y", "Z"](-8) [[q2]]#0, [[q2]]#1, [[q1]], [[q0]] 
-    
+    // CHECK: [[q3:%.+]]:4 = qec.ppr ["Z", "Z", "Y", "Z"](-8) [[q2]]#0, [[q2]]#1, [[q1]], [[q0]]
+
     // q3, q2, q1, q4
-    // CHECK: [[m1:%.+]], [[o1:%.+]]:4 = qec.ppm ["Z", "Z", "Y", "Y"] [[q3]]#0, [[q3]]#1, [[q3]]#3, [[q3]]#2 
+    // CHECK: [[m1:%.+]], [[o1:%.+]]:4 = qec.ppm ["Z", "Z", "Y", "Y"] [[q3]]#0, [[q3]]#1, [[q3]]#3, [[q3]]#2
 
     // q2, q1
     // CHECK: [[m2:%.+]], [[o2:%.+]]:2 = qec.ppm ["X", "X"] [[o1]]#1, [[o1]]#2
@@ -149,7 +178,6 @@ func.func public @game_of_surface_code(%arg0: !quantum.bit, %arg1: !quantum.bit,
     return
 }
 
-
 func.func public @circuit_transformed_0() -> (tensor<i1>, tensor<i1>) {
 
     // CHECK: [[qreg:%.+]] = quantum.alloc( 2) : !quantum.reg