- Modified state-prep to avoid-y-measure

- Updated docstring
- Renamed variable name

Author: sengthai

frontend/catalyst/passes/builtin_passes.py

@@ -501,7 +501,7 @@ def circuit():
     return PassPipelineWrapper(qnode, "merge_ppr_ppm")
 
 
-def ppr_to_ppm(qnode=None, decompose_method="auto-corrected", prepare_state="zero"):
+def ppr_to_ppm(qnode=None, decompose_method="auto-corrected", avoid_y_measure=False):
     R"""Specify that the MLIR compiler passes for decomposing Pauli Product rotations (PPR)
     into Pauli Pauli measurements (PPM) will be applied.
 
@@ -568,7 +568,7 @@ def circuit():
     """
     passes = {
         "decompose_non_clifford_ppr": {"decompose-method": decompose_method},
-        "decompose_clifford_ppr": {"prep-state": prepare_state},
+        "decompose_clifford_ppr": {"avoid-y-measure": avoid_y_measure},
     }
 
     def decorator(qnode_func):

frontend/test/pytest/test_peephole_optimizations.py

@@ -196,8 +196,6 @@ def test_chained_apply_passes_workflow(x: float):
     assert "merge-rotations" in test_chained_apply_passes_workflow.mlir
 
 
-test_chained_passes()
-
 #
 # to_ppr
 #
@@ -227,9 +225,6 @@ def f():
     assert 'transform.apply_registered_pass "to_ppr"' not in optimized_ir
     assert "qec.ppr" in optimized_ir
 
-
-test_convert_clifford_to_ppr()
-
 #
 # commute_ppr
 #
@@ -262,9 +257,6 @@ def f():
     assert "qec.ppr" in optimized_ir
     assert "qec.ppm" in optimized_ir
 
-
-test_commute_ppr()
-
 #
 # merge_ppr_ppm
 #
@@ -280,13 +272,11 @@ def test_merge_ppr_ppm():
     def test_merge_ppr_ppm_workflow():
 
         @to_ppr
-        @commute_ppr
         @merge_ppr_ppm
         @qml.qnode(qml.device("lightning.qubit", wires=2))
         def f():
             qml.H(0)
             qml.S(1)
-            qml.T(0)
             qml.CNOT([0, 1])
             return measure(0), measure(1)
 
@@ -316,8 +306,6 @@ def test_ppr_to_ppm():
     def test_ppr_to_ppm_workflow():
 
         @to_ppr
-        @commute_ppr
-        @merge_ppr_ppm
         @ppr_to_ppm
         @qml.qnode(qml.device("lightning.qubit", wires=2))
         def f():
@@ -348,7 +336,7 @@ def f():
 test_ppr_to_ppm()
 
 #
-# ppr_to_ppm with inject-magic-state
+# ppr_to_ppm with clifford-corrected
 #
 
 
@@ -362,9 +350,7 @@ def test_ppr_to_ppm_inject_magic_state():
     def test_ppr_to_ppm_workflow():
 
         @to_ppr
-        @commute_ppr
-        @merge_ppr_ppm
-        @ppr_to_ppm(decompose_method="inject-magic-state", prepare_state="plus_i")
+        @ppr_to_ppm(decompose_method="clifford-corrected", avoid_y_measure=True)
         @qml.qnode(qml.device("lightning.qubit", wires=2))
         def f():
             qml.H(0)
@@ -391,7 +377,5 @@ def f():
     assert 'qec.ppr ["X"]' in optimized_ir
 
 
-test_ppr_to_ppm_inject_magic_state()
-
 if __name__ == "__main__":
     pytest.main(["-x", __file__])

mlir/include/QEC/IR/QECDialect.td

@@ -404,11 +404,9 @@ def PPMeasurementOp : QEC_Op<"ppm", [QECOpInterface, AttrSizedOperandSegments]>
 }
 
 def SelectPPMeasurementOp : QEC_Op<"select.ppm"> {
-    let summary = "Conditional Pauli product measurement based on a boolean control.";
+    let summary = "Multiplexed Pauli product measurement.";
 
     let description = [{
-    Conditionally applies and Pauli Product Measurement on qubits.
-
     Based on the boolean `condition` (type `i1`), this op selects between two Pauli product strings:  
     - If `condition` is 1, applies and measures using `pauli_product`.  
     - If `condition` is 0, uses `else_pauli_product`.  

mlir/include/QEC/Transforms/Passes.td

@@ -38,10 +38,10 @@ def CommuteCliffordTPPRPass : Pass<"commute_ppr"> {
     let constructor = "catalyst::createCommuteCliffordTPPRPass()";
 }
 
-def DecompositionMethod : I32EnumAttr<"DecompositionMethod", "Decomposition method", 
+def DecomposeMethod : I32EnumAttr<"DecomposeMethod", "Decomposition method", 
     [
     I32EnumAttrCase<"AutoCorrected", 0, "auto-corrected">,
-    I32EnumAttrCase<"InjectMagicState", 1, "inject-magic-state">
+    I32EnumAttrCase<"CliffordCorrected", 1, "clifford-corrected">
     ]> { 
     let cppNamespace = "catalyst::qec";
     let genSpecializedAttr = 0; 
@@ -50,29 +50,23 @@ def DecompositionMethod : I32EnumAttr<"DecompositionMethod", "Decomposition meth
 def DecomposeMethodOption : Option<
     /*C++ var name=*/"decomposeMethod",
     /*CLI arg name=*/"decompose-method",
-    /*type=*/"::catalyst::qec::DecompositionMethod",
-    /*default=*/"::catalyst::qec::DecompositionMethod::AutoCorrected",
+    /*type=*/"::catalyst::qec::DecomposeMethod",
+    /*default=*/"::catalyst::qec::DecomposeMethod::AutoCorrected",
     "Decomposition method to use",
     [{::llvm::cl::values(
-        clEnumValN(::catalyst::qec::DecompositionMethod::AutoCorrected,
+        clEnumValN(::catalyst::qec::DecomposeMethod::AutoCorrected,
                     "auto-corrected", "Decompose using auto-corrected method."),
-        clEnumValN(::catalyst::qec::DecompositionMethod::InjectMagicState,
-                    "inject-magic-state",
+        clEnumValN(::catalyst::qec::DecomposeMethod::CliffordCorrected,
+                    "clifford-corrected",
                     "Decompose by injecting magic states method.")
     )}]>;
 
-def PrepareStateOption : Option<
-    /*C++ var name=*/"prepareState",
-    /*CLI arg name=*/"prep-state",
-    /*type=*/"::catalyst::qec::LogicalInitKind",
-    /*default=*/"::catalyst::qec::LogicalInitKind::zero",
-    "Initial state of logical qubit", 
-    [{::llvm::cl::values(
-        clEnumValN(::catalyst::qec::LogicalInitKind::zero,
-                    "zero", "Initial state is |0⟩."),
-        clEnumValN(::catalyst::qec::LogicalInitKind::plus_i,
-                    "plus_i", "Initial state is |+i⟩.")
-    )}]>;
+def AvoidYMeasureOption : Option<
+    /*C++ var name=*/"avoidYMeasure",
+    /*CLI arg name=*/"avoid-y-measure",
+    /*type=*/"bool",
+    /*default=*/"false",
+    "Avoid Pauli-Y measurements for Clifford rotations. Rather than performing a Pauli-Y measurement for Clifford rotations (sometimes more costly), a Y state is used instead (requires Y state preparation).">;
 
 def CommuteCliffordPastPPMPass : Pass<"merge_ppr_ppm"> {
     let summary = "Absorb Clifford operations into Pauli Product Measurement operations.";
@@ -103,7 +97,7 @@ def DecomposeCliffordPPRPass : Pass<"decompose_clifford_ppr"> {
         "catalyst::qec::QECDialect",
     ];
 
-    let options = [PrepareStateOption];
+    let options = [AvoidYMeasureOption];
 
     let constructor = "catalyst::createDecomposeCliffordPPRPass()";
 }

mlir/include/QEC/Transforms/Patterns.h

@@ -14,20 +14,20 @@
 
 #pragma once
 
-#include "QEC/Transforms/Passes.h" // need for DecompositionMethod
 #include "mlir/Conversion/LLVMCommon/TypeConverter.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Transforms/DialectConversion.h"
 
 #include "QEC/IR/QECDialect.h"
+#include "QEC/Transforms/Passes.h" // need for DecomposeMethod
 
 namespace catalyst {
 namespace qec {
 
 void populateCliffordTToPPRPatterns(mlir::RewritePatternSet &);
 void populateCommuteCliffordTPPRPatterns(mlir::RewritePatternSet &);
 void populateCommuteCliffordPastPPMPatterns(mlir::RewritePatternSet &);
-void populateDecomposeNonCliffordPPRPatterns(mlir::RewritePatternSet &, DecompositionMethod);
+void populateDecomposeNonCliffordPPRPatterns(mlir::RewritePatternSet &, DecomposeMethod);
 void populateDecomposeCliffordPPRPatterns(mlir::RewritePatternSet &, LogicalInitKind);
 
 } // namespace qec

mlir/lib/QEC/Transforms/DecomposeNonCliffordPPR.cpp

@@ -172,9 +172,9 @@ void decompose_inject_magic_state_pi_over_eight(PPRotationOp op, PatternRewriter
 struct DecomposeNonCliffordPPR : public OpRewritePattern<PPRotationOp> {
     using OpRewritePattern::OpRewritePattern;
 
-    DecompositionMethod method;
+    DecomposeMethod method;
 
-    DecomposeNonCliffordPPR(MLIRContext *context, DecompositionMethod method,
+    DecomposeNonCliffordPPR(MLIRContext *context, DecomposeMethod method,
                             PatternBenefit benefit = 1)
         : OpRewritePattern(context, benefit), method(method)
     {
@@ -184,10 +184,10 @@ struct DecomposeNonCliffordPPR : public OpRewritePattern<PPRotationOp> {
     {
         if (op.isNonClifford() && !op.getCondition()) {
             switch (method) {
-            case DecompositionMethod::AutoCorrected:
+            case DecomposeMethod::AutoCorrected:
                 decompose_auto_corrected_pi_over_eight(op, rewriter);
                 break;
-            case DecompositionMethod::InjectMagicState:
+            case DecomposeMethod::CliffordCorrected:
                 decompose_inject_magic_state_pi_over_eight(op, rewriter);
                 break;
             }
@@ -202,7 +202,7 @@ namespace catalyst {
 namespace qec {
 
 void populateDecomposeNonCliffordPPRPatterns(RewritePatternSet &patterns,
-                                             DecompositionMethod decomposeMethod)
+                                             DecomposeMethod decomposeMethod)
 {
     patterns.add<DecomposeNonCliffordPPR>(patterns.getContext(), decomposeMethod, 1);
 }

mlir/lib/QEC/Transforms/decompose_clifford_ppr.cpp

@@ -41,7 +41,12 @@ struct DecomposeCliffordPPRPass
     {
         RewritePatternSet patterns(&getContext());
 
-        populateDecomposeCliffordPPRPatterns(patterns, prepareState);
+        LogicalInitKind ancillaType = LogicalInitKind::zero;
+        if (avoidYMeasure) {
+            ancillaType = LogicalInitKind::plus_i;
+        }
+
+        populateDecomposeCliffordPPRPatterns(patterns, ancillaType);
 
         if (failed(applyPatternsAndFoldGreedily(getOperation(), std::move(patterns)))) {
             return signalPassFailure();

mlir/test/QEC/DecomposeCliffordPPR.mlir

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_clifford_ppr{prep-state=zero})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-Z
-// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_clifford_ppr{prep-state=plus_i})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-Y
+// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_clifford_ppr)" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-Z
+// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_clifford_ppr{avoid-y-measure=true})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-Y
 
 func.func @test_ppr_to_ppm(%q1 : !quantum.bit) {
     %0 = qec.ppr ["Z"](4) %q1 : !quantum.bit

mlir/test/QEC/DecomposeNonCliffordPPR.mlir

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_non_clifford_ppr{decompose-method=inject-magic-state})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-INJECT
+// RUN: quantum-opt --pass-pipeline="builtin.module(decompose_non_clifford_ppr{decompose-method=clifford-corrected})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-INJECT
 // RUN: quantum-opt --pass-pipeline="builtin.module(decompose_non_clifford_ppr{decompose-method=auto-corrected})" --split-input-file -verify-diagnostics %s | FileCheck %s --check-prefix=CHECK-AUTO
 
 func.func @test_ppr_to_ppm(%q1 : !quantum.bit) {