✨ Implement two-qubit gate decomposition pass

.clang-tidy

@@ -74,3 +74,5 @@ CheckOptions:
     value: CamelCase
   - key: readability-identifier-naming.VariableCase
     value: camelBack
+  - key: misc-include-cleaner.IgnoreHeaders
+    value: "Eigen/.*;unsupported/Eigen/.*"

CMakeLists.txt

@@ -23,6 +23,18 @@ include(PreventInSourceBuilds)
 include(PackageAddTest)
 include(Cache)
 include(AddMQTCoreLibrary)
+include(FetchContent)
+
+FetchContent_Declare(
+  Eigen
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG 3.4.1
+  GIT_SHALLOW TRUE)
+FetchContent_MakeAvailable(Eigen)
+if(WIN32 AND ${CMAKE_HOST_SYSTEM_PROCESSOR} STREQUAL ARM64)
+  message(STATUS "Enabling non-optimal vectorization in Eigen to avoid alignment issues")
+  add_compile_definitions(EIGEN_DONT_ALIGN_STATICALLY)
+endif()
 
 option(BUILD_MQT_CORE_BINDINGS "Build the MQT Core Python bindings" OFF)
 if(BUILD_MQT_CORE_BINDINGS)

mlir/include/mlir/CMakeLists.txt

@@ -6,5 +6,6 @@
 #
 # Licensed under the MIT License
 
-add_subdirectory(Dialect)
 add_subdirectory(Conversion)
+add_subdirectory(Dialect)
+add_subdirectory(Passes)

mlir/include/mlir/Compiler/CompilerPipeline.h

@@ -119,6 +119,11 @@ class QuantumCompilerPipeline {
    */
   static void addCleanupPasses(PassManager& pm);
 
+  /**
+   * @brief Add all available optimization passes
+   */
+  static void addOptimizationPasses(PassManager& pm);
+
   /**
    * @brief Configure PassManager with diagnostic options
    *

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

@@ -7,6 +7,6 @@
 # Licensed under the MIT License
 
 add_mlir_dialect(QCOOps qco)
-add_mlir_interface(QCOInterfaces)
+add_mlir_interface(QCOInterfaces LINK_LIBS PUBLIC Eigen3::Eigen)
 add_mlir_doc(QCOOps MLIRQCODialect Dialects/ -gen-dialect-doc)
 add_mlir_doc(QCOInterfaces MLIRQCOInterfaces Dialects/ -gen-op-interface-docs -dialect=qco)

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

@@ -21,13 +21,18 @@
 #pragma clang diagnostic pop
 #endif
 
+#include "mlir/Dialect/Utils/MatrixUtils.h"
+
+#include <Eigen/Core>
+#include <Eigen/SparseCore>
 #include <mlir/Bytecode/BytecodeOpInterface.h>
 #include <mlir/Dialect/Arith/IR/Arith.h>
 #include <mlir/IR/Value.h>
 #include <mlir/IR/ValueRange.h>
 #include <mlir/Interfaces/SideEffectInterfaces.h>
 #include <optional>
 #include <string>
+#include <unsupported/Eigen/src/KroneckerProduct/KroneckerTensorProduct.h>
 #include <variant>
 
 #define DIALECT_NAME_QCO "qco"
@@ -43,6 +48,7 @@
 //===----------------------------------------------------------------------===//
 
 #define GET_TYPEDEF_CLASSES
+#include "mlir/Dialect/QCO/IR/QCOInterfaces.h.inc"
 #include "mlir/Dialect/QCO/IR/QCOOpsTypes.h.inc"
 
 //===----------------------------------------------------------------------===//
@@ -51,6 +57,13 @@
 
 namespace mlir::qco {
 
+/**
+ * @brief Retrieve C++ type of static mlir::Value.
+ * @details The returned float attribute can be used to get the value of the
+ *          given parameter as a C++ type.
+ */
+[[nodiscard]] inline std::optional<double>
+tryGetParameterAsDouble(UnitaryOpInterface op, size_t i);
 /**
  * @brief Trait for operations with a fixed number of target qubits and
  * parameters
@@ -60,8 +73,15 @@ namespace mlir::qco {
  * verification and code generation optimizations.
  * @tparam T The target arity.
  * @tparam P The parameter arity.
+ * @tparam MatrixDefinition A function returning the matrix definition of the
+ *                          operation. The operation will be provided as the
+ *                          only argument of the function. If the operation does
+ *                          not have a matrix definition, set this value to
+ *                          nullptr.
  */
-template <size_t T, size_t P> class TargetAndParameterArityTrait {
+template <size_t T, size_t P, typename UnitaryMatrixType,
+          UnitaryMatrixType (*MatrixDefinition)(UnitaryOpInterface)>
+class TargetAndParameterArityTrait {
 public:
   template <typename ConcreteType>
   class Impl : public OpTrait::TraitBase<ConcreteType, Impl> {
@@ -108,6 +128,11 @@ template <size_t T, size_t P> class TargetAndParameterArityTrait {
       return this->getOperation()->getOperand(T + i);
     }
 
+    /**
+     * @brief Retrieve mlir::FloatAttr of static mlir::Value.
+     * @details The returned float attribute can be used to get the value of the
+     *          given parameter as a C++ type or perform other mlir operations.
+     */
     [[nodiscard]] static FloatAttr getStaticParameter(Value param) {
       auto constantOp = param.getDefiningOp<arith::ConstantOp>();
       if (!constantOp) {
@@ -116,6 +141,13 @@ template <size_t T, size_t P> class TargetAndParameterArityTrait {
       return dyn_cast<FloatAttr>(constantOp.getValue());
     }
 
+    [[nodiscard]] UnitaryMatrixType getUnitaryMatrixDefinition() const
+      requires(MatrixDefinition != nullptr)
+    {
+      const auto* op = this->getConstOperation();
+      return MatrixDefinition(llvm::dyn_cast<UnitaryOpInterface>(op));
+    }
+
     Value getInputForOutput(Value output) {
       const auto& op = this->getOperation();
       for (size_t i = 0; i < T; ++i) {
@@ -136,16 +168,105 @@ template <size_t T, size_t P> class TargetAndParameterArityTrait {
       llvm::reportFatalUsageError(
           "Given qubit is not an input of the operation");
     }
+
+  protected:
+    [[nodiscard]] const Operation* getConstOperation() const {
+      auto* concrete = static_cast<const ConcreteType*>(this);
+      // use dereference operator instead of getOperation() of mlir::Op; the
+      // operator provides a const overload, getOperation() does not
+      return *concrete;
+    }
   };
 };
 
 } // namespace mlir::qco
 
-#include "mlir/Dialect/QCO/IR/QCOInterfaces.h.inc" // IWYU pragma: export
+// #include "mlir/Dialect/QCO/IR/QCOInterfaces.h.inc" // IWYU pragma: export
+
+//===----------------------------------------------------------------------===//
+// Operations Helpers
+//===----------------------------------------------------------------------===//
+
+namespace mlir::qco {
+
+[[nodiscard]] inline std::optional<double>
+tryGetParameterAsDouble(UnitaryOpInterface op, size_t i) {
+  using DummyArityType =
+      TargetAndParameterArityTrait<0, 0, Eigen::MatrixXcd, nullptr>;
+  const auto param = op.getParameter(i);
+  const auto floatAttr =
+      DummyArityType::Impl<arith::ConstantOp>::getStaticParameter(param);
+  if (!floatAttr) {
+    return std::nullopt;
+  }
+  return floatAttr.getValueAsDouble();
+}
+
+[[nodiscard]] inline std::pair<Eigen::MatrixXcd, Eigen::VectorXi>
+permutate(const Eigen::MatrixXcd& inputMatrix,
+          const Eigen::VectorXi& permutation) {
+  const auto swapMatrix = utils::getMatrixSWAP();
+
+  auto dim = inputMatrix.cols();
+  assert(inputMatrix.cols() == inputMatrix.rows());
+  assert(dim == permutation.size());
+
+  Eigen::MatrixXcd permutatedMatrix(dim, dim);
+  Eigen::VectorXi undoPermutation(permutation.size());
+  for (int i = 0; i < permutation.size(); ++i) {
+    undoPermutation(permutation(i)) = i;
+    // TODO
+  }
+
+  return {permutatedMatrix, undoPermutation};
+}
+
+[[nodiscard]] inline Eigen::MatrixXcd getBlockMatrix(size_t dim,
+                                                     mlir::Region& region) {
+  // TODO: check if dim == region.getArguments().size()
+  assert(dim == 1); // TODO: remove once permutations are properly handled
+
+  Eigen::MatrixXcd result = Eigen::MatrixXcd::Identity(1 << dim, 1 << dim);
+  for (auto&& block : region) {
+    for (auto&& op : block) {
+      auto unitaryOp = llvm::dyn_cast<mlir::qco::UnitaryOpInterface>(op);
+      if (unitaryOp) {
+        return result;
+      }
+      auto matrix = unitaryOp.getUnitaryMatrix();
+      size_t matrixDim = matrix.cols();
+      if (matrixDim < dim) {
+        // TODO: permutate such that operation qubits are next to each other;
+        //       then perform front/back padding accordingly
+
+        auto paddingDim = dim - matrixDim;
+        auto padding =
+            Eigen::MatrixXcd::Identity(1 << paddingDim, 1 << paddingDim);
+        matrix = Eigen::kroneckerProduct(matrix, padding);
+
+        // TODO: undo permutation
+      }
+      result = matrix * result;
+    }
+  }
+  return result;
+}
+
+mlir::Region& getCtrlBody(UnitaryOpInterface op);
+
+} // namespace mlir::qco
 
 //===----------------------------------------------------------------------===//
 // Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/QCO/IR/QCOOps.h.inc" // IWYU pragma: export
+
+namespace mlir::qco {
+
+[[nodiscard]] inline mlir::Region& getCtrlBody(UnitaryOpInterface op) {
+  return llvm::cast<CtrlOp>(op).getBody();
+}
+
+} // namespace mlir::qco

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

@@ -28,6 +28,7 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
 
     let cppNamespace = "::mlir::qco";
 
+    // TODO: fix const correctness?
     let methods = [
         // Qubit accessors
         InterfaceMethod<
@@ -89,25 +90,45 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
         InterfaceMethod<
             "Returns true if the operation has any control qubits, otherwise false.",
             "bool", "isControlled", (ins),
-            [{ return getNumControls(impl, tablegen_opaque_val) > 0; }]
+            [{ return $_op.getNumControls() > 0; }]
         >,
         InterfaceMethod<
             "Returns true if the operation only acts on a single qubit.",
             "bool", "isSingleQubit", (ins),
-            [{ return getNumQubits(impl, tablegen_opaque_val) == 1; }]
+            [{ return $_op.getNumQubits() == 1; }]
         >,
         InterfaceMethod<
             "Returns true if the operation acts on two qubits.",
             "bool", "isTwoQubit", (ins),
-            [{ return getNumQubits(impl, tablegen_opaque_val) == 2; }]
+            [{ return $_op.getNumQubits() == 2; }]
         >,
 
         // Identification
         InterfaceMethod<
             "Returns the base symbol/mnemonic of the operation.",
             "StringRef", "getBaseSymbol", (ins)
         >,
+
+        // Unitary matrix methods
+        InterfaceMethod<
+            "Returns the unitary matrix definition of the operation.",
+            "Eigen::MatrixXcd", "getUnitaryMatrix", (ins),
+            [{
+              if constexpr (requires { $_op.getUnitaryMatrixDefinition(); }) {
+                return $_op.getUnitaryMatrixDefinition();
+              } else {
+                llvm::reportFatalUsageError("Operation '" + $_op.getBaseSymbol() + "' has no unitary matrix definition!");
+              }
+            }]
+        >,
     ];
+
+    let extraTraitClassDeclaration = [{
+      template<typename MatrixType>
+      MatrixType getFastUnitaryMatrix() const {
+        return $_op.getUnitaryMatrixDefinition();
+      }
+    }];
 }
 
 #endif // QCO_INTERFACES