MLIR Plugin

Makefile

@@ -0,0 +1,16 @@
+.PHONY: plugin
+
+CATALYST_BASE_DIR := /Users/patrickhopf/Code/catalyst/mlir
+CATALYST_BUILD_DIR := $(CATALYST_BASE_DIR)/build
+LLVM_BUILD_DIR := $(CATALYST_BASE_DIR)/llvm-project/build
+LLVM_EXTERNAL_LIT := $(LLVM_BUILD_DIR)/bin/llvm-lit
+CATALYST_TOOLS_DIR := $(LLVM_BUILD_DIR)/bin
+
+plugin:
+	cmake -B build -G Ninja \
+		-DCatalyst_DIR=$(CATALYST_BUILD_DIR)/lib/cmake/catalyst \
+		-DMLIR_DIR=$(LLVM_BUILD_DIR)/lib/cmake/mlir \
+		-DBUILD_MQT_CORE_MLIR=ON \
+
+	cmake --build build
+	cmake --build build --target quantum-opt

mlir/CMakeLists.txt

@@ -5,6 +5,9 @@
 #
 # Licensed under the MIT License
 
+# HACK
+cmake_policy(SET CMP0057 NEW)
+
 # set the include directory for the build tree
 set(MQT_MLIR_INCLUDE_BUILD_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 

mlir/include/mlir/Dialect/MQTOpt/IR/MQTOptTraits.h

@@ -17,7 +17,7 @@ template <size_t N> class TargetArity {
 public:
   template <typename ConcreteOp>
   class Impl : public mlir::OpTrait::TraitBase<ConcreteOp, Impl> {
-    static llvm::LogicalResult verifyTrait(mlir::Operation* op) {
+    static mlir::LogicalResult verifyTrait(mlir::Operation* op) {
       auto unitaryOp = mlir::cast<ConcreteOp>(op);
       if (const auto size = unitaryOp.getInQubits().size(); size != N) {
         return op->emitError()
@@ -32,7 +32,7 @@ template <size_t N> class ParameterArity {
 public:
   template <typename ConcreteOp>
   class Impl : public mlir::OpTrait::TraitBase<ConcreteOp, Impl> {
-    static llvm::LogicalResult verifyTrait(mlir::Operation* op) {
+    static mlir::LogicalResult verifyTrait(mlir::Operation* op) {
       auto paramOp = mlir::cast<ConcreteOp>(op);
       const auto& params = paramOp.getParams();
       const auto& staticParams = paramOp.getStaticParams();

mlir/tools/CMakeLists.txt

@@ -6,3 +6,4 @@
 # Licensed under the MIT License
 
 add_subdirectory(quantum-opt)
+add_subdirectory(mqt-plugin)

mlir/tools/mqt-plugin/CMakeLists.txt

@@ -0,0 +1,28 @@
+# Copyright (c) 2025 Chair for Design Automation, TUM
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+set(PLUGIN_OUTPUT_DIR "${CMAKE_SOURCE_DIR}/mqt_plugin_wheel/mqt_plugin")
+add_compile_options(-fexceptions)
+
+add_llvm_library(
+  MQTPlugin
+  MODULE
+  BUILDTREE_ONLY
+  mqt-plugin.cpp
+  DEPENDS
+  MLIRMQTOpt
+  MLIRMQTOptTransforms
+  PLUGIN_TOOL
+  catalyst-cli
+  LINK_LIBS
+  MLIRMQTOpt
+  MLIRMQTOptTransforms
+  ${MLIRQuantum_LIB} # Link directly to the static library
+)
+
+# Set output directory for the plugin to be shipped with the wheel
+set_target_properties(MQTPlugin PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${PLUGIN_OUTPUT_DIR}")

mlir/tools/mqt-plugin/mqt-plugin.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2025 Chair for Design Automation, TUM
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+//===- mqt-plugin.cpp ------------------------------------*- C++ -*-===//
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/MQTOpt/IR/MQTOptDialect.h"
+#include "mlir/Dialect/MQTOpt/Transforms/Passes.h"
+#include "mlir/IR/MLIRContext.h"
+#include "mlir/Tools/Plugins/DialectPlugin.h"
+#include "mlir/Tools/Plugins/PassPlugin.h"
+
+#include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Compiler.h"
+
+using namespace mlir;
+
+/// Dialect plugin registration mechanism.
+/// Observe that it also allows to register passes.
+/// Necessary symbol to register the dialect plugin.
+extern "C" LLVM_ATTRIBUTE_WEAK DialectPluginLibraryInfo
+mlirGetDialectPluginInfo() {
+  return {MLIR_PLUGIN_API_VERSION, "MQTOpt", LLVM_VERSION_STRING,
+          [](DialectRegistry* registry) {
+            registry->insert<::mqt::ir::opt::MQTOptDialect>();
+          }};
+}
+
+/// Pass plugin registration mechanism.
+/// Necessary symbol to register the pass plugin.
+extern "C" LLVM_ATTRIBUTE_WEAK PassPluginLibraryInfo mlirGetPassPluginInfo() {
+  return {MLIR_PLUGIN_API_VERSION, "MQTOptPasses", LLVM_VERSION_STRING,
+          []() { mqt::ir::opt::registerMQTOptPasses(); }};
+}

mqt_plugin_wheel/MANIFEST.in

@@ -0,0 +1,9 @@
+# Copyright (c) 2025 Chair for Design Automation, TUM
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+include mqt_plugin/lib/*
+include mqt_plugin/test/*.py

mqt_plugin_wheel/mqt_plugin/__init__.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2025 Chair for Design Automation, TUM
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""MQT Plugin interface."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pennylane as qml
+from catalyst.passes import PassPlugin
+
+
+def getMQTPluginAbsolutePath():
+    """Returns the absolute path to the MQT plugin."""
+    ext = "dylib"  # TODO: we should provide "so" as well
+    # ext = "so" if platform.system() == "Linux" else "dylib"
+    return Path(Path(__file__).parent.absolute(), f"MQTPlugin.{ext}")
+
+
+def name2pass(_name):
+    """Example entry point for MQT plugin."""
+    return getMQTPluginAbsolutePath(), "mqt-core-round-trip"
+
+
+def MQTCoreRoundTrip(*flags, **valued_options):
+    """Applies the "mqt-core-round-trip" pass."""
+
+    def add_pass_to_pipeline(**kwargs):
+        pass_pipeline = kwargs.get("pass_pipeline", [])
+        pass_pipeline.append(
+            PassPlugin(
+                getMQTPluginAbsolutePath(),
+                "mqt-core-round-trip",
+                *flags,
+                **valued_options,
+            )
+        )
+        return pass_pipeline
+
+    def decorator(qnode):
+        if not isinstance(qnode, qml.QNode):
+            # Technically, this apply pass is general enough that it can apply to
+            # classical functions too. However, since we lack the current infrastructure
+            # to denote a function, let's limit it to qnodes
+            msg = f"A QNode is expected, got the classical function {qnode}"
+            raise TypeError(msg)
+
+        def qnode_call(*args, **kwargs):
+            kwargs["pass_pipeline"] = add_pass_to_pipeline(**kwargs)
+            return qnode(*args, **kwargs)
+
+        return qnode_call
+
+    # When the decorator is used without ()
+    if len(flags) == 1 and isinstance(flags[0], qml.QNode):
+        qnode = flags[0]
+
+        def qnode_call(*args, **kwargs):
+            kwargs["pass_pipeline"] = add_pass_to_pipeline(**kwargs)
+            return qnode(*args, **kwargs)
+
+        return qnode_call
+
+    # When the decorator is used with ()
+    return decorator

mqt_plugin_wheel/mqt_plugin/test/dev_config.toml

@@ -0,0 +1,6 @@
+# PennyLane dvice configuration file
+
+["main"]
+shots = 1024
+wires = 2
+cmap = [[0, 1], [1, 0]]

mqt_plugin_wheel/mqt_plugin/test/test_mlir_plugin.py

@@ -0,0 +1,168 @@
+# Copyright (c) 2025 Chair for Design Automation, TUM
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+# Copyright 2024 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This file performs the frontend lit tests that the peephole transformations are correctly lowered.
+
+We check the transform jax primitives for each pass is correctly injected
+during tracing, and these transform primitives are correctly lowered to the mlir before
+running -apply-transform-sequence.
+"""
+
+# RUN: %PYTHON %s | FileCheck %s
+
+# pylint: disable=line-too-long
+from __future__ import annotations
+
+from pathlib import Path
+
+import pennylane as qml
+from catalyst import CompileError, pipeline
+from pennylane.configuration import Configuration
+from utils import print_jaxpr, print_mlir
+from utils import qjit_for_tests as qjit
+
+
+def flush_peephole_opted_mlir_to_iostream(QJIT) -> None:
+    """The QJIT compiler does not offer a direct interface to access an intermediate mlir in the pipeline.
+    The `QJIT.mlir` is the mlir before any passes are run, i.e. the "0_<qnode_name>.mlir".
+    Since the QUANTUM_COMPILATION_PASS is located in the middle of the pipeline, we need
+    to retrieve it with keep_intermediate=True and manually access the "2_QuantumCompilationPass.mlir".
+    Then we delete the kept intermediates to avoid pollution of the workspace.
+    """
+
+
+#
+# pipeline
+#
+
+
+def test_pipeline_lowering() -> None:
+    """Basic pipeline lowering on one qnode."""
+    my_pipeline = {
+        "cancel_inverses": {},
+        "merge_rotations": {},
+    }
+
+    @qjit(keep_intermediate=True, verbose=True)
+    @pipeline(my_pipeline)
+    @qml.qnode(qml.device("lightning.qubit", wires=2))
+    def test_pipeline_lowering_workflow(x):
+        qml.RX(x, wires=[0])
+        qml.Hadamard(wires=[1])
+        qml.Hadamard(wires=[1])
+        return qml.expval(qml.PauliY(wires=0))
+
+    # CHECK: pipeline=(remove-chained-self-inverse, merge-rotations)
+    print_jaxpr(test_pipeline_lowering_workflow, 1.2)
+
+    # CHECK: transform.named_sequence @__transform_main
+    # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "remove-chained-self-inverse" to {{%.+}}
+    # CHECK-NEXT: {{%.+}} = transform.apply_registered_pass "merge-rotations" to {{%.+}}
+    # CHECK-NEXT: transform.yield
+    print_mlir(test_pipeline_lowering_workflow, 1.2)
+
+    # CHECK: {{%.+}} = call @test_pipeline_lowering_workflow_transformed_0(
+    # CHECK: func.func public @test_pipeline_lowering_workflow_transformed_0(
+    # CHECK: {{%.+}} = quantum.custom "RX"({{%.+}}) {{%.+}} : !quantum.bit
+    # CHECK-NOT: {{%.+}} = quantum.custom "Hadamard"() {{%.+}} : !quantum.bit
+    # CHECK-NOT: {{%.+}} = quantum.custom "Hadamard"() {{%.+}} : !quantum.bit
+    test_pipeline_lowering_workflow(42.42)
+    flush_peephole_opted_mlir_to_iostream(test_pipeline_lowering_workflow)
+
+
+def test_MQT_plugin() -> bool | None:
+    """Generate MLIR for the MQT plugin via entry-point.
+
+    HACK required to make this test work!
+
+    1. in catalyst/pipelines.py, add the following line:
+
+        def get_enforce_runtime_invariants_stage(_options: CompileOptions) -> List[str]:
+            ...
+            enforce_runtime_invariants = [
+                ...
+                "builtin.module(mqt-core-round-trip)", # HACK
+                "builtin.module(apply-transform-sequence)",
+                ...
+            ]
+
+    2. in catalyst/compiler.py, add the following line:
+
+        def run_from_ir(self, ir: str, module_name: str, workspace: Directory):
+            ...
+            cmd = self.get_cli_command(tmp_infile_name, output_ir_name, module_name, workspace)
+            cmd += ["--debug"] # HACK
+            try:
+                ...
+
+    """
+    my_pipeline = {
+        "mqt.mqt-core-round-trip": {"cmap": [[0, 1], [1, 0]]},
+        # "mqt.mqt-core-round-trip": {},
+    }
+
+    config_path = Path(__file__).parent / "dev_config.toml"
+    Configuration(config_path)
+    dev = qml.device(
+        name="lightning.qubit", wires=2
+    )  # config=conf)#"lightning.qubit", {'wires': 2, 'cmap': [[0, 1], [1, 0]]})
+
+    try:
+
+        @qjit(keep_intermediate=True, verbose=True)
+        @pipeline(my_pipeline)
+        @qml.qnode(dev)
+        def test_pipeline_mqtplugin_workflow() -> None:
+            qml.Hadamard(wires=[0])
+
+        test_pipeline_mqtplugin_workflow()
+        flush_peephole_opted_mlir_to_iostream(test_pipeline_mqtplugin_workflow)
+
+    except CompileError as error:  # Expecting failure, because MQT plugin does not cover full roundtrip (yet)
+        error_msg = str(error)  # Recover the output after application of the MQT conversion pass
+        try:
+            mlir_str = error_msg.split("module @module_test_pipeline_mqtplugin_workflow_transformed {")[1]
+            mlir_str = error_msg.split("}\n}")[0]
+        except:
+            return False
+
+        transformed = [
+            r"%c = stablehlo.constant dense<0> : tensor<i64>",
+            r"%extracted = tensor.extract %c[] : tensor<i64>",
+            r"quantum.device shots(%extracted) ",  # ... there is more in this line
+            r"%c_0 = stablehlo.constant dense<1> : tensor<i64>",
+            r'%0 = "mqtopt.allocQubitRegister"() <{size_attr = 1 : i64}> : () -> !mqtopt.QubitRegister',
+            r"%c_1 = stablehlo.constant dense<0> : tensor<i64>",
+            r"%extracted_2 = tensor.extract %c_1[] : tensor<i64>",
+            r'%out_qureg, %out_qubit = "mqtopt.extractQubit"(%0, %extracted_2) : (!mqtopt.QubitRegister, i64) -> (!mqtopt.QubitRegister, !mqtopt.Qubit)',
+            r"%1 = mqtopt.H() %out_qubit : !mqtopt.Qubit",
+            r"%c_3 = stablehlo.constant dense<0> : tensor<i64>",
+            r"%extracted_4 = tensor.extract %c_3[] : tensor<i64>",
+            r'%2 = "mqtopt.insertQubit"(%out_qureg, %1, %extracted_4) : (!mqtopt.QubitRegister, !mqtopt.Qubit, i64) -> !mqtopt.QubitRegister',
+            r'"mqtopt.deallocQubitRegister"(%2) : (!mqtopt.QubitRegister) -> ()',
+            r"quantum.device_release",
+            r"return",
+        ]
+
+        return all(t in mlir_str for t in transformed)
+
+
+test_MQT_plugin()