✨ Add native gate synthesis MLIR pass and decomposition stack

CHANGELOG.md

@@ -12,6 +12,9 @@ with the exception that minor releases may include breaking changes.
 
 ### Added
 
+- ✨ Add a `fuse-two-qubit-unitary-runs` pass
+  for fusing compile-time two-qubit unitary windows via Weyl/KAK resynthesis
+  ([#1655]) ([**@simon1hofmann**])
 - ✨ Add a `fuse-single-qubit-unitary-runs` pass
   for fusing compile-time single-qubit unitary runs via Euler resynthesis
   ([#1672]) ([**@simon1hofmann**], [**@burgholzer**])
@@ -632,6 +635,7 @@ changelogs._
 [#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
+[#1655]: https://github.com/munich-quantum-toolkit/core/pull/1655
 [#1652]: https://github.com/munich-quantum-toolkit/core/pull/1652
 [#1638]: https://github.com/munich-quantum-toolkit/core/pull/1638
 [#1637]: https://github.com/munich-quantum-toolkit/core/pull/1637

mlir/include/mlir/Compiler/CompilerPipeline.h

@@ -49,6 +49,18 @@ struct QuantumCompilerConfig {
 
   /// Enable Hadamard lifting
   bool enableHadamardLifting = false;
+
+  /// Comma-separated native gate menu. Recognised tokens: `u`, `x`, `sx`,
+  /// `rz` (or `p`), `rx`, `ry`, `r`, `cx`, `cz`, `rzz`.
+  /// Illustrative menus (use `cx` or `cz` as the entangler, or
+  /// both):
+  /// - `"x,sx,rz,cx"` / `"x,sx,rz,cz"` — IBM basic (no fractional 2q)
+  /// - `"x,sx,rz,rx,rzz,cx"` / `"...,cz"` — IBM fractional
+  /// - `"u,cx"` / `"u,cz"` — generic single-qubit U3 + CX/CZ
+  /// - `"r,cz"` — IQM-style default
+  /// - `"rx,rz,cx"`, `"rx,ry,cz"`, `"ry,rz,cx"` — supported RX/RY/RZ pairs plus
+  /// entangler
+  std::string nativeGates;
 };
 
 /**
@@ -84,7 +96,7 @@ struct CompilationRecord {
  * 2. QC cleanup pipeline
  * 3. QCO dialect (value semantics) - enables SSA-based optimizations
  * 4. QCO cleanup pipeline
- * 5. Quantum optimization passes
+ * 5. Optimization and native gate synthesis
  * 6. QCO cleanup pipeline
  * 7. QC dialect - converted back for backend lowering
  * 8. QC cleanup pipeline

mlir/include/mlir/Dialect/QCO/Transforms/Decomposition/Euler.h

@@ -32,6 +32,7 @@ enum class EulerBasis : std::uint8_t {
   XYX = 3,  ///< `RX(phi) * RY(theta) * RX(lambda)`.
   U = 4,    ///< `U(theta, phi, lambda)`.
   ZSXX = 5, ///< `RZ` / `SX` / `X` synthesis via ZYZ decomposition.
+  R = 6,    ///< `R(.,0) * R(.,pi/2) * R(.,0)` (XYX with `Rx`/`Ry` as `R`).
 };
 
 /**
@@ -42,6 +43,31 @@ enum class EulerBasis : std::uint8_t {
  */
 [[nodiscard]] std::optional<EulerBasis> parseEulerBasis(StringRef basis);
 
+/**
+ * @brief Euler angles `(theta, phi, lambda)` and global phase for a 2x2
+ * unitary.
+ *
+ * The decomposition obeys `matrix == e^{i*phase} * K(phi) * A(theta) *
+ * K(lambda)` where `(K, A)` are the rotation axes of the chosen @ref
+ * EulerBasis.
+ */
+struct EulerAngles {
+  double theta = 0.0;  ///< Middle rotation angle.
+  double phi = 0.0;    ///< First outer rotation angle.
+  double lambda = 0.0; ///< Second outer rotation angle.
+  double phase = 0.0;  ///< Global phase in radians.
+};
+
+/**
+ * @brief Extracts `(theta, phi, lambda, phase)` of @p matrix in @p basis.
+ *
+ * @param matrix The single-qubit unitary to decompose.
+ * @param basis The target Euler basis.
+ * @return The extracted Euler angles and global phase.
+ */
+[[nodiscard]] EulerAngles anglesFromUnitary(const Matrix2x2& matrix,
+                                            EulerBasis basis);
+
 /**
  * @brief Synthesizes a composed single-qubit unitary as gates in @p basis.
  *

mlir/include/mlir/Dialect/QCO/Transforms/Decomposition/NativeProfile.h

@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2023 - 2026 Chair for Design Automation, TUM
+ * Copyright (c) 2025 - 2026 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "mlir/Dialect/QCO/IR/QCOInterfaces.h"
+#include "mlir/Dialect/QCO/IR/QCOOps.h"
+#include "mlir/Dialect/QCO/Transforms/Decomposition/Euler.h"
+#include "mlir/Dialect/QCO/Utils/Matrix.h"
+
+#include <llvm/ADT/DenseSet.h>
+#include <llvm/ADT/SmallVector.h>
+#include <mlir/IR/Builders.h>
+#include <mlir/IR/Location.h>
+#include <mlir/IR/Operation.h>
+#include <mlir/IR/Value.h>
+#include <mlir/Support/LLVM.h>
+#include <mlir/Support/LogicalResult.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace mlir::qco::decomposition {
+
+/**
+ * @brief Native gate kinds that may appear in a two-qubit synthesis menu.
+ */
+enum class NativeGateKind : std::uint8_t {
+  U,
+  X,
+  Sx,
+  Rz,
+  Rx,
+  Ry,
+  R,
+  Cx,
+  Cz,
+  Rzz,
+};
+
+/**
+ * @brief Single-qubit emission strategy resolved from a native-gate menu.
+ */
+enum class SingleQubitMode : std::uint8_t {
+  ZSXX,     ///< `RZ` / `SX` / `X` via ZYZ decomposition.
+  U3,       ///< Generic `U(theta, phi, lambda)`.
+  R,        ///< `R(theta, phi)` chain (`Rx`/`Ry` as `R`).
+  AxisPair, ///< Two fixed rotation axes (see @ref AxisPair).
+};
+
+/**
+ * @brief Rotation-axis pair for @ref SingleQubitMode::AxisPair emitters.
+ */
+enum class AxisPair : std::uint8_t {
+  RxRz,
+  RxRy,
+  RyRz,
+};
+
+/**
+ * @brief Entangling basis gate for two-qubit Weyl synthesis.
+ */
+enum class EntanglerBasis : std::uint8_t {
+  None,
+  Cx,
+  Cz,
+};
+
+struct SingleQubitEmitterSpec {
+  SingleQubitMode mode = SingleQubitMode::U3;
+  AxisPair axisPair = AxisPair::RxRz;
+  bool supportsDirectRx = false;
+};
+
+/**
+ * @brief Resolved native-gate menu for two-qubit Weyl synthesis.
+ */
+struct NativeProfileSpec {
+  bool allowRzz = false;
+  llvm::DenseSet<NativeGateKind> allowedGates;
+  llvm::SmallVector<SingleQubitEmitterSpec> singleQubitEmitters;
+  llvm::SmallVector<EntanglerBasis> entanglerBases;
+};
+
+/**
+ * @brief Euler basis used to emit single-qubit factors for @p emitter.
+ */
+[[nodiscard]] EulerBasis
+emitterEulerBasis(const SingleQubitEmitterSpec& emitter);
+
+/**
+ * @brief Parses a comma-separated native-gate menu (e.g. `"u,cx,rzz"`).
+ */
+[[nodiscard]] std::optional<NativeProfileSpec>
+parseNativeSpec(StringRef nativeGates);
+
+/**
+ * @brief Synthesizes a composed two-qubit unitary as gates in @p spec.
+ */
+[[nodiscard]] LogicalResult
+synthesizeUnitary2QWeyl(OpBuilder& builder, Location loc, Value qubit0,
+                        Value qubit1, const Matrix4x4& target,
+                        const NativeProfileSpec& spec, Value& outQubit0,
+                        Value& outQubit1);
+
+/**
+ * @brief Number of entangling basis gates required to synthesize @p target.
+ *
+ * @return Entangler count for @p spec, or `std::nullopt` if synthesis fails.
+ */
+[[nodiscard]] std::optional<std::uint8_t>
+twoQubitEntanglerCount(const Matrix4x4& target, const NativeProfileSpec& spec);
+
+/**
+ * @brief Maps a compile-time single-qubit op to its native-menu gate kind.
+ *
+ * Returns `std::nullopt` for non-primitive or unsupported ops.
+ */
+[[nodiscard]] std::optional<NativeGateKind>
+nativeGateKindFor(UnitaryOpInterface op);
+
+/**
+ * @brief Returns true when @p op is already on the resolved single-qubit menu.
+ *
+ * `BarrierOp` and `GPhaseOp` are always allowed.
+ */
+[[nodiscard]] bool allowsSingleQubitOp(UnitaryOpInterface op,
+                                       const NativeProfileSpec& spec);
+
+/**
+ * @brief Entangler basis for a 1-control, 1-target `CtrlOp` with `X`/`Z` body.
+ */
+[[nodiscard]] std::optional<EntanglerBasis>
+entanglerBasisForSingleTargetCtrl(CtrlOp ctrl);
+
+/** @brief Returns true when @p spec lists @p basis as an entangler. */
+[[nodiscard]] bool profileAllowsEntangler(const NativeProfileSpec& spec,
+                                          EntanglerBasis basis);
+
+/**
+ * @brief Returns true when a 1-control, 1-target `CtrlOp` is on @p spec.
+ */
+[[nodiscard]] bool allowsSingleTargetCtrl(CtrlOp ctrl,
+                                          const NativeProfileSpec& spec);
+
+/**
+ * @brief Returns true when a bare two-qubit op (currently `RZZ`) is on @p spec.
+ */
+[[nodiscard]] bool allowsBareTwoQubitOp(Operation* op,
+                                        const NativeProfileSpec& spec);
+
+/**
+ * @brief Returns true when @p op is a native two-qubit gate under @p spec.
+ */
+[[nodiscard]] bool allowsTwoQubitOp(Operation* op,
+                                    const NativeProfileSpec& spec);
+
+/**
+ * @brief Fills @p matrix with the 4x4 unitary for a two-qubit block op.
+ *
+ * Handles single-target `CtrlOp` shells and generic two-qubit unitaries.
+ * Returns false for barriers, global phase, and unsupported shapes.
+ */
+[[nodiscard]] bool assignTwoQubitOpMatrix(Operation* op, Matrix4x4& matrix);
+
+} // namespace mlir::qco::decomposition