Cleanup to satisfy coderabittai

Author: taminob

CMakeLists.txt

@@ -23,7 +23,6 @@ include(PreventInSourceBuilds)
 include(PackageAddTest)
 include(Cache)
 include(AddMQTCoreLibrary)
-include(FetchContent)
 
 option(BUILD_MQT_CORE_BINDINGS "Build the MQT Core Python bindings" OFF)
 if(BUILD_MQT_CORE_BINDINGS)

cmake/ExternalDependencies.cmake

@@ -27,8 +27,10 @@ if(BUILD_MQT_CORE_MLIR)
     Eigen
     GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
     GIT_TAG 5.0.1
-    GIT_SHALLOW TRUE)
-  FetchContent_MakeAvailable(Eigen)
+    GIT_SHALLOW TRUE
+    FIND_PACKAGE_ARGS 3.4.0 # minimum version for locally installed package
+  )
+  list(APPEND FETCH_PACKAGES Eigen)
 endif()
 
 set(JSON_VERSION

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

@@ -29,7 +29,6 @@
 #include <mlir/Interfaces/SideEffectInterfaces.h>
 #include <optional>
 #include <string>
-#include <unsupported/Eigen/KroneckerProduct>
 #include <variant>
 
 #define DIALECT_NAME_QCO "qco"
@@ -55,13 +54,6 @@
 
 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
@@ -71,11 +63,6 @@ tryGetParameterAsDouble(UnitaryOpInterface op, size_t i);
  * 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 {
 public:
@@ -144,14 +131,6 @@ 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;
-    }
   };
 };
 
@@ -163,11 +142,3 @@ template <size_t T, size_t P> class TargetAndParameterArityTrait {
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/QCO/IR/QCOOps.h.inc" // IWYU pragma: export
-
-namespace mlir::qco {
-
-[[nodiscard]] inline UnitaryOpInterface getControlledOp(UnitaryOpInterface op) {
-  return llvm::cast<CtrlOp>(op).getBodyUnitary();
-}
-
-} // namespace mlir::qco

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

@@ -28,7 +28,6 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
 
     let cppNamespace = "::mlir::qco";
 
-    // TODO: fix const correctness?
     let methods = [
         // Qubit accessors
         InterfaceMethod<
@@ -146,12 +145,20 @@ def UnitaryOpInterface : OpInterface<"UnitaryOpInterface"> {
 
         if constexpr (std::is_same_v<std::remove_cvref_t<MatrixType>, Eigen::MatrixXcd>) {
           // cast to Eigen::MatrixXcd via visitor pattern
-          auto&& visitor = [](auto&& m) -> std::optional<MatrixType> { return m; };
+          auto&& visitor = [](auto&& m) -> std::optional<MatrixType> {
+            // implicit cast to Eigen::MatrixXcd if variant holds a matrix type;
+            // if variant holds std::nullopt_t, std::optional will be initialized with
+            // the std::nullopt_t instance, so std::nullopt
+            return m;
+          };
           return std::visit(visitor, matrix);
         } else {
           // if an explicit size has been requested, use checked access to variant
-          // to return the correct type (throws on wrong type)
-          return std::get<MatrixType>(matrix);
+          // to try to return the correct type
+          if (auto* ptr = std::get_if<MatrixType>(matrix)) {
+            return *ptr;
+          }
+          return std::nullopt;
         }
       }
     }];

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

@@ -243,7 +243,6 @@ class TargetAndParameterArityTrait<int T, int P>
     let cppNamespace = "::mlir::qco";
 }
 
-def ZeroTargetZeroParameter : TargetAndParameterArityTrait<0, 0>;
 def ZeroTargetOneParameter : TargetAndParameterArityTrait<0, 1>;
 def OneTargetZeroParameter : TargetAndParameterArityTrait<1, 0>;
 def OneTargetOneParameter : TargetAndParameterArityTrait<1, 1>;
@@ -1004,7 +1003,7 @@ def XXMinusYYOp : QCOOp<"xx_minus_yy", traits = [UnitaryOpInterface, TwoTargetTw
     let hasCanonicalizer = 1;
 }
 
-def BarrierOp : QCOOp<"barrier", traits = [UnitaryOpInterface, ZeroTargetZeroParameter]> {
+def BarrierOp : QCOOp<"barrier", traits = [UnitaryOpInterface]> {
     let summary = "Apply a barrier gate to a set of qubits";
     let description = [{
         Applies a barrier gate to a set of qubits and returns the transformed qubits.

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

@@ -375,7 +375,7 @@ std::optional<Eigen::MatrixXcd> CtrlOp::getUnitaryMatrix() {
   assert(targetMatrix->cols() == targetMatrix->rows());
 
   // define dimensions and type of output matrix
-  const auto dim = static_cast<int64_t>((1 << getNumControls()) * targetDim);
+  const auto dim = static_cast<int64_t>((1ULL << getNumControls()) * targetDim);
 
   // initialize result with identity
   Eigen::MatrixXcd matrix = Eigen::MatrixXcd::Identity(dim, dim);