✨ Add QCO Euler synthesis and fuse-single-qubit-unitary-runs pass

CHANGELOG.md

@@ -11,6 +11,7 @@ This project adheres to [Semantic Versioning], with the exception that minor rel
 
 ### Added
 
+- ✨ Add a `fuse-single-qubit-unitary-runs` pass for fusing compile-time single-qubit unitary runs via Euler resynthesis ([#1672]) ([**@simon1hofmann**])
 - 🚸 Add [CMake presets] to provide a standardized and reproducible way to configure builds ([#1660]) ([**@denialhaag**])
 - ✨ Add a `quantum-loop-unroll` pass for unrolling for-loop operations containing quantum operations ([#1718]) ([**@MatthiasReumann**])
 - ✨ Add a `hadamard-lifting` pass for lifting Hadamard gates above Pauli gates ([#1605]) ([**@lirem101**], [**@burgholzer**])
@@ -422,6 +423,7 @@ _📚 Refer to the [GitHub Release Notes](https://github.com/munich-quantum-tool
 [#1675]: https://github.com/munich-quantum-toolkit/core/pull/1675
 [#1674]: https://github.com/munich-quantum-toolkit/core/pull/1674
 [#1673]: https://github.com/munich-quantum-toolkit/core/pull/1673
+[#1672]: https://github.com/munich-quantum-toolkit/core/pull/1672
 [#1664]: https://github.com/munich-quantum-toolkit/core/pull/1664
 [#1662]: https://github.com/munich-quantum-toolkit/core/pull/1662
 [#1660]: https://github.com/munich-quantum-toolkit/core/pull/1660

mlir/include/mlir/Dialect/QCO/IR/CMakeLists.txt

@@ -8,6 +8,9 @@
 
 add_mlir_dialect(QCOOps qco)
 add_mlir_interface(QCOInterfaces)
+add_mlir_interface(QCOUnitaryMatrixInterfaces)
 
 add_mlir_doc(QCOOps QCODialect Dialects/ -gen-dialect-doc)
 add_mlir_doc(QCOInterfaces QCOInterfaces Dialects/ -gen-op-interface-docs -dialect=qco)
+add_mlir_doc(QCOUnitaryMatrixInterfaces QCOUnitaryMatrixInterfaces Dialects/ -gen-op-interface-docs
+             -dialect=qco)

mlir/include/mlir/Dialect/QCO/IR/QCOInterfaces.h

@@ -10,7 +10,6 @@
 
 #pragma once
 
-#include <Eigen/Core>
 #include <llvm/Support/ErrorHandling.h>
 #include <mlir/IR/OpDefinition.h>
 #include <mlir/Support/LLVM.h>

mlir/include/mlir/Dialect/QCO/IR/QCOInterfaces.td

@@ -28,62 +28,6 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
 
   let cppNamespace = "::mlir::qco";
 
-  // Generic implementation body for getUnitaryMatrix methods
-  defvar unitaryMatrixMethodBody = [{
-      auto process = [&]<typename MatrixType>(MatrixType&& m) -> bool {
-          using TargetT = std::remove_cvref_t<decltype(out)>;
-          using SourceT = std::remove_cvref_t<MatrixType>;
-
-          constexpr bool isTargetDynamic =
-              (TargetT::SizeAtCompileTime == Eigen::Dynamic);
-          constexpr bool isSourceDynamic =
-              (SourceT::SizeAtCompileTime == Eigen::Dynamic);
-
-          // Case 1: Target is Dynamic. Always accepts source.
-          if constexpr (isTargetDynamic) {
-            out = std::forward<MatrixType>(m);
-            return true;
-          }
-          // Case 2: Target is Fixed.
-          else {
-            // Case 2a: Source is Dynamic. Runtime dimension check required.
-            if constexpr (isSourceDynamic) {
-              if (m.rows() == static_cast<Eigen::Index>(TargetT::RowsAtCompileTime) &&
-                  m.cols() == static_cast<Eigen::Index>(TargetT::ColsAtCompileTime))
-                  [[likely]] {
-                out = std::forward<MatrixType>(m);
-                return true;
-              }
-            }
-            // Case 2b: Source is Fixed. Compile-time check.
-            else if constexpr (static_cast<Eigen::Index>(
-                                   SourceT::RowsAtCompileTime) ==
-                                   static_cast<Eigen::Index>(
-                                       TargetT::RowsAtCompileTime) &&
-                               static_cast<Eigen::Index>(
-                                   SourceT::ColsAtCompileTime) ==
-                                   static_cast<Eigen::Index>(
-                                       TargetT::ColsAtCompileTime)) {
-              out = std::forward<MatrixType>(m);
-              return true;
-            }
-          }
-          return false;
-        };
-
-
-      if constexpr (requires { $_op.getUnitaryMatrix().has_value(); }) {
-        if (auto&& matrix = $_op.getUnitaryMatrix()) {
-          return process(std::move(*matrix));
-        }
-        return false;
-      } else if constexpr (requires { $_op.getUnitaryMatrix(); }) {
-        return process($_op.getUnitaryMatrix());
-      } else {
-        llvm::reportFatalUsageError("Operation '" + $_op.getBaseSymbol() + "' has no unitary matrix definition!");
-      }
-    }];
-
   let methods = [
       // Qubit accessors
       InterfaceMethod<
@@ -152,60 +96,7 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
 
       // Identification
       InterfaceMethod<"Returns the base symbol/mnemonic of the operation.",
-                      "StringRef", "getBaseSymbol", (ins)>,
-
-      // Unitary matrix helpers
-      InterfaceMethod<"Populates the given 1x1 unitary matrix if possible.",
-                      "bool", "getUnitaryMatrix1x1",
-                      (ins "Eigen::Matrix<std::complex<double>, 1, 1>&":$out),
-                      unitaryMatrixMethodBody>,
-      InterfaceMethod<"Populates the given 2x2 unitary matrix if possible.",
-                      "bool", "getUnitaryMatrix2x2",
-                      (ins "Eigen::Matrix2cd&":$out), unitaryMatrixMethodBody>,
-      InterfaceMethod<"Populates the given 4x4 unitary matrix if possible.",
-                      "bool", "getUnitaryMatrix4x4",
-                      (ins "Eigen::Matrix4cd&":$out), unitaryMatrixMethodBody>,
-      InterfaceMethod<"Populates the given dynamic unitary matrix.", "bool",
-                      "getUnitaryMatrixDynamic", (ins "Eigen::MatrixXcd&":$out),
-                      unitaryMatrixMethodBody>];
-
-  let extraClassDeclaration = [{
-        template<typename MatrixType>
-        std::optional<MatrixType> getUnitaryMatrix() {
-          MatrixType out;
-          bool result = false;
-
-          // Dispatch to the appropriate fixed-size or dynamic method based on the
-          // matrix type.
-          if constexpr (MatrixType::RowsAtCompileTime == 1 &&
-                        MatrixType::ColsAtCompileTime == 1) {
-            result = this->getUnitaryMatrix1x1(out);
-          } else if constexpr (MatrixType::RowsAtCompileTime == 2 &&
-                               MatrixType::ColsAtCompileTime == 2) {
-            result = this->getUnitaryMatrix2x2(out);
-          } else if constexpr (MatrixType::RowsAtCompileTime == 4 &&
-                               MatrixType::ColsAtCompileTime == 4) {
-            result = this->getUnitaryMatrix4x4(out);
-          } else if constexpr (MatrixType::SizeAtCompileTime == Eigen::Dynamic) {
-            result = this->getUnitaryMatrixDynamic(out);
-          } else {
-            // Fallback: Try obtaining dynamic matrix and see if size matches
-            Eigen::MatrixXcd dynamicOut;
-            if (this->getUnitaryMatrixDynamic(dynamicOut)) {
-              if (dynamicOut.rows() == MatrixType::RowsAtCompileTime &&
-                  dynamicOut.cols() == MatrixType::ColsAtCompileTime) {
-                out = dynamicOut;
-                result = true;
-              }
-            }
-          }
-
-          if (result) {
-            return out;
-          }
-          return std::nullopt;
-        }
-    }];
+                      "StringRef", "getBaseSymbol", (ins)>];
 }
 
 #endif // MLIR_DIALECT_QCO_IR_QCOINTERFACES_TD

mlir/include/mlir/Dialect/QCO/IR/QCOOps.h

@@ -23,6 +23,7 @@
 
 #include "mlir/Dialect/QCO/IR/QCODialect.h"
 #include "mlir/Dialect/QCO/IR/QCOInterfaces.h"
+#include "mlir/Dialect/QCO/IR/QCOUnitaryMatrixInterfaces.h"
 
 #include <mlir/Bytecode/BytecodeOpInterface.h>
 #include <mlir/Interfaces/ControlFlowInterfaces.h>