conversion tests

🎨 pre-commit fixes

Author: J4MMlE

mlir/lib/Dialect/QC/IR/Modifiers/PowOp.cpp

@@ -15,8 +15,6 @@
 #include <llvm/ADT/STLFunctionalExtras.h>
 #include <llvm/ADT/TypeSwitch.h>
 #include <llvm/Support/Casting.h>
-
-#include <cstdint>
 #include <mlir/Dialect/Arith/IR/Arith.h>
 #include <mlir/IR/Builders.h>
 #include <mlir/IR/MLIRContext.h>
@@ -26,6 +24,7 @@
 #include <mlir/Support/LogicalResult.h>
 
 #include <cmath>
+#include <cstdint>
 #include <numbers>
 
 using namespace mlir;

mlir/lib/Dialect/QCO/IR/Modifiers/PowOp.cpp

@@ -15,8 +15,6 @@
 #include <Eigen/Core>
 #include <Eigen/Eigenvalues>
 #include <llvm/ADT/STLFunctionalExtras.h>
-
-#include <cstdint>
 #include <llvm/ADT/SmallVector.h>
 #include <llvm/ADT/TypeSwitch.h>
 #include <llvm/Support/Casting.h>
@@ -33,6 +31,7 @@
 
 #include <cmath>
 #include <cstddef>
+#include <cstdint>
 #include <numbers>
 #include <optional>
 

mlir/unittests/Conversion/QCOToQC/test_qco_to_qc.cpp

@@ -148,17 +148,10 @@ INSTANTIATE_TEST_SUITE_P(
 INSTANTIATE_TEST_SUITE_P(
     QCOPowOpTest, QCOToQCTest,
     testing::Values(
-        QCOToQCTestCase{"PowSingleExponent",
-                        MQT_NAMED_BUILDER(qco::powSingleExponent),
-                        MQT_NAMED_BUILDER(qc::powSingleExponent)},
-        QCOToQCTestCase{"NestedPow", MQT_NAMED_BUILDER(qco::nestedPow),
-                        MQT_NAMED_BUILDER(qc::powSingleExponent)},
-        QCOToQCTestCase{"PowRxx", MQT_NAMED_BUILDER(qco::powRxx),
-                        MQT_NAMED_BUILDER(qc::powRxx)},
-        QCOToQCTestCase{"NegPowRx", MQT_NAMED_BUILDER(qco::negPowRx),
-                        MQT_NAMED_BUILDER(qc::negPowRx)},
-        QCOToQCTestCase{"InvPowRx", MQT_NAMED_BUILDER(qco::invPowRx),
-                        MQT_NAMED_BUILDER(qc::powRxNeg)}));
+        // pow(1/3){SX} inside ctrl: fold would emit gphase+rx (two ops,
+        // invalid in ctrl body) → pow survives and hits ConvertQCOPowOp
+        QCOToQCTestCase{"CtrlPowSx", MQT_NAMED_BUILDER(qco::ctrlPowSx),
+                        MQT_NAMED_BUILDER(qc::ctrlPowSx)}));
 /// @}
 
 /// \name QCOToQC/Modifiers/InvOp.cpp

mlir/unittests/Conversion/QCToQCO/test_qc_to_qco.cpp

@@ -146,18 +146,11 @@ INSTANTIATE_TEST_SUITE_P(
 /// @{
 INSTANTIATE_TEST_SUITE_P(
     QCPowOpTest, QCToQCOTest,
-    testing::Values(QCToQCOTestCase{"PowSingleExponent",
-                                    MQT_NAMED_BUILDER(qc::powSingleExponent),
-                                    MQT_NAMED_BUILDER(qco::powSingleExponent)},
-                    QCToQCOTestCase{"NestedPow",
-                                    MQT_NAMED_BUILDER(qc::nestedPow),
-                                    MQT_NAMED_BUILDER(qco::powSingleExponent)},
-                    QCToQCOTestCase{"PowRxx", MQT_NAMED_BUILDER(qc::powRxx),
-                                    MQT_NAMED_BUILDER(qco::powRxx)},
-                    QCToQCOTestCase{"NegPowRx", MQT_NAMED_BUILDER(qc::negPowRx),
-                                    MQT_NAMED_BUILDER(qco::negPowRx)},
-                    QCToQCOTestCase{"InvPowRx", MQT_NAMED_BUILDER(qc::invPowRx),
-                                    MQT_NAMED_BUILDER(qco::powRxNeg)}));
+    testing::Values(
+        // pow(1/3){SX} inside ctrl: fold would emit gphase+rx (two ops,
+        // invalid in ctrl body) → pow survives and hits ConvertQCPowOp
+        QCToQCOTestCase{"CtrlPowSx", MQT_NAMED_BUILDER(qc::ctrlPowSx),
+                        MQT_NAMED_BUILDER(qco::ctrlPowSx)}));
 /// @}
 
 /// \name QCToQCO/Modifiers/InvOp.cpp

mlir/unittests/programs/qc_programs.cpp

@@ -1608,4 +1608,9 @@ void ctrlPowRx(QCProgramBuilder& b) {
   b.ctrl(q[0], [&] { b.pow(2.0, [&] { b.rx(0.123, q[1]); }); });
 }
 
+void ctrlPowSx(QCProgramBuilder& b) {
+  auto q = b.allocQubitRegister(2);
+  b.ctrl(q[0], [&] { b.pow(1.0 / 3.0, [&] { b.sx(q[1]); }); });
+}
+
 } // namespace mlir::qc

mlir/unittests/programs/qc_programs.h

@@ -1040,4 +1040,9 @@ void powCtrlRx(QCProgramBuilder& b);
 /// powCtrlRx).
 void ctrlPowRx(QCProgramBuilder& b);
 
+/// Creates a circuit with ctrl wrapping pow(1/3) wrapping SX. The fold
+/// pow(p){SX} → gphase+rx is suppressed inside ctrl (would emit two ops),
+/// so the pow survives canonicalization and reaches ConvertQCPowOp.
+void ctrlPowSx(QCProgramBuilder& b);
+
 } // namespace mlir::qc

mlir/unittests/programs/qco_programs.cpp

@@ -2571,6 +2571,18 @@ void ctrlPowRx(QCOProgramBuilder& b) {
   });
 }
 
+void ctrlPowSx(QCOProgramBuilder& b) {
+  auto q = b.allocQubitRegister(2);
+  b.ctrl({q[0]}, {q[1]}, [&](mlir::ValueRange targets) {
+    auto inner =
+        b.pow({targets[0]}, 1.0 / 3.0, [&](mlir::ValueRange powArgs) {
+          auto q0 = b.sx(powArgs[0]);
+          return llvm::SmallVector<mlir::Value>{q0};
+        });
+    return llvm::SmallVector<mlir::Value>{inner};
+  });
+}
+
 // --- IfOp ---------------------------------------------------------------- //
 
 void simpleIf(QCOProgramBuilder& b) {

mlir/unittests/programs/qco_programs.h

@@ -1186,6 +1186,11 @@ void powCtrlRx(QCOProgramBuilder& b);
 /// powCtrlRx).
 void ctrlPowRx(QCOProgramBuilder& b);
 
+/// Creates a circuit with ctrl wrapping pow(1/3) wrapping SX. The fold
+/// pow(p){SX} → gphase+rx is suppressed inside ctrl (would emit two ops),
+/// so the pow survives canonicalization and reaches ConvertQCOPowOp.
+void ctrlPowSx(QCOProgramBuilder& b);
+
 // --- IfOp ---------------------------------------------------------------- //
 
 /// Creates a circuit with a simple if operation with one qubit.