Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

CHANGELOG.md (1)

15-17: 📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win

Document controlled-phase and RCCX decomposition.

The entry currently advertises only X and Z, omitting two noteworthy capabilities introduced by this PR.

Proposed wording

-- ✨ Add a `decompose-multi-controlled` pass for decomposing controlled X and Z
-  gates with a configurable `min-controls` threshold ([`#1810`])
+- ✨ Add a `decompose-multi-controlled` pass for decomposing multi-controlled
+  X, Z, phase, and RCCX operations with a configurable `min-controls` threshold
+  ([`#1810`])

As per coding guidelines, “Update CHANGELOG.md for user-facing, breaking, or otherwise noteworthy changes.”

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

- ✨ Add a `decompose-multi-controlled` pass for decomposing multi-controlled
  X, Z, phase, and RCCX operations with a configurable `min-controls` threshold
  ([`#1810`])
  ([**`@simon1hofmann`**])

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@CHANGELOG.md` around lines 15 - 17, Update the changelog entry for the
decompose-multi-controlled pass to mention controlled-phase and RCCX
decomposition in addition to controlled X and Z gates, while retaining the
configurable min-controls threshold and existing attribution.

Source: Coding guidelines

mlir/include/mlir/Dialect/QCO/IR/QCOOps.td (1)

788-816: 🎯 Functional Correctness | 🔴 Critical | ⚡ Quick win

Add Pure trait and remove [MemRead] from linear value arguments.

RCCXOp is missing the Pure trait, and its arguments are incorrectly annotated with [MemRead]. Qubit values in the QCO dialect are linear SSA values, not memory pointers, so they do not incur memory read side effects.

Adding the Pure trait ensures that standard MLIR optimizations (like CSE and canonicalization) correctly model this operation as side-effect free, consistent with all other unitary gates (e.g., XOp, SWAPOp).

🐛 Proposed fix

-def RCCXOp
-    : QCOOp<"rccx", traits = [UnitaryOpInterface, ThreeTargetZeroParameter]> {
+def RCCXOp : QCOOp<"rccx",
+                   traits = [UnitaryOpInterface, ThreeTargetZeroParameter, Pure]> {
   let summary = "Apply a relative-phase CCX gate to three qubits";
   let description = [{
         Applies a relative-phase Toffoli (`RCCX`) to three qubits and returns the
         transformed qubits. The gate acts as a controlled `@f`$X@f$ on `@f`$q_2@f$
         when `@f`$q_0@f$ and `@f`$q_1@f$ are `@f`$|1\rangle@f$, but may introduce a
         non-trivial phase on `@f`$|111\rangle@f$ relative to a standard `CCX`.
         This matches the `rccx` gate in OpenQASM 3 `qelib1.inc` and is commonly
         used as a building block in multi-controlled `@f`$X@f$ decompositions.
 
         Example:
         ```mlir
         %c0_out, %c1_out, %t_out = qco.rccx %c0_in, %c1_in, %t_in
             : !qco.qubit, !qco.qubit, !qco.qubit
             -> !qco.qubit, !qco.qubit, !qco.qubit
         ```
     }];
 
   let arguments =
-      (ins Arg<QubitType, "the first control qubit", [MemRead]>:$qubit0_in,
-          Arg<QubitType, "the second control qubit", [MemRead]>:$qubit1_in,
-          Arg<QubitType, "the target qubit", [MemRead]>:$qubit2_in);
+      (ins Arg<QubitType, "the first control qubit">:$qubit0_in,
+          Arg<QubitType, "the second control qubit">:$qubit1_in,
+          Arg<QubitType, "the target qubit">:$qubit2_in);
   let results = (outs QubitType:$qubit0_out, QubitType:$qubit1_out,
       QubitType:$qubit2_out);

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

def RCCXOp : QCOOp<"rccx",
                   traits = [UnitaryOpInterface, ThreeTargetZeroParameter, Pure]> {
  let summary = "Apply a relative-phase CCX gate to three qubits";
  let description = [{
        Applies a relative-phase Toffoli (`RCCX`) to three qubits and returns the
        transformed qubits. The gate acts as a controlled `@f`$X@f$ on `@f`$q_2@f$
        when `@f`$q_0@f$ and `@f`$q_1@f$ are `@f`$|1\rangle@f$, but may introduce a
        non-trivial phase on `@f`$|111\rangle@f$ relative to a standard `CCX`.
        This matches the `rccx` gate in OpenQASM 3 `qelib1.inc` and is commonly
        used as a building block in multi-controlled `@f`$X@f$ decompositions.

        Example:

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@mlir/include/mlir/Dialect/QCO/IR/QCOOps.td` around lines 788 - 816, Update
RCCXOp’s trait list to include Pure alongside UnitaryOpInterface and
ThreeTargetZeroParameter, and remove the MemRead annotations from qubit0_in,
qubit1_in, and qubit2_in so the linear qubit arguments are modeled without
memory-read effects.

mlir/include/mlir/Dialect/QCO/Transforms/Passes.td (1)

65-67: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Remove the unsupported r Euler basis.

Advertising r may lead users to select a basis this pass cannot synthesize.

Proposed fix

-      "Target Euler basis (zyz, zxz, xzx, xyx, u, zsxx, r).">];
+      "Target Euler basis (zyz, zxz, xzx, xyx, u, zsxx).">];

Based on learnings, the supported bases are exactly zyz, zxz, xzx, xyx, u, and zsxx.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

  let options = [Option<
      "basis", "basis", "std::string", "\"zyz\"",
      "Target Euler basis (zyz, zxz, xzx, xyx, u, zsxx).">];

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@mlir/include/mlir/Dialect/QCO/Transforms/Passes.td` around lines 65 - 67,
Update the basis option declaration in the pass options to remove the
unsupported “r” value from its description, leaving exactly zyz, zxz, xzx, xyx,
u, and zsxx as advertised supported Euler bases.

Source: Learnings

mlir/lib/Dialect/QCO/IR/Operations/StandardGates/RCCXOp.cpp (1)

18-42: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

Cache the static unitary matrix to avoid repeated dynamic allocations.

RCCXOp::getUnitaryMatrix() returns a constant 8x8 unitary. Building this matrix from scratch dynamically on every call requires numerous heap allocations and heavy matrix multiplications, which can become a bottleneck during compiler passes.

Please consider caching the result using a thread-safe static variable (C++11 magic statics) so the matrix is only computed once.

⚡ Proposed optimization

 static DynamicMatrix elementaryRCCXUnitary() {
-  constexpr Matrix4x4 cx =
-      Matrix4x4::fromElements(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
-                              0.0, 1.0, 0.0, 0.0, 1.0, 0.0);
-
-  DynamicMatrix unitary = DynamicMatrix::identity(8);
-  const auto apply1 = [&](const Matrix2x2& gate, const std::size_t qubit) {
-    unitary = gate.embedInNqubit(3, qubit) * unitary;
-  };
-  const auto applyCx = [&](const std::size_t control,
-                           const std::size_t target) {
-    unitary = cx.embedInNqubit(3, control, target) * unitary;
-  };
-
-  apply1(HOp::getUnitaryMatrix(), 2);
-  apply1(TOp::getUnitaryMatrix(), 2);
-  applyCx(1, 2);
-  apply1(TdgOp::getUnitaryMatrix(), 2);
-  applyCx(0, 2);
-  apply1(TOp::getUnitaryMatrix(), 2);
-  applyCx(1, 2);
-  apply1(TdgOp::getUnitaryMatrix(), 2);
-  apply1(HOp::getUnitaryMatrix(), 2);
-  return unitary;
+  static const DynamicMatrix unitary = [] {
+    constexpr Matrix4x4 cx =
+        Matrix4x4::fromElements(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
+                                0.0, 1.0, 0.0, 0.0, 1.0, 0.0);
+
+    DynamicMatrix u = DynamicMatrix::identity(8);
+    const auto apply1 = [&](const Matrix2x2& gate, const std::size_t qubit) {
+      u = gate.embedInNqubit(3, qubit) * u;
+    };
+    const auto applyCx = [&](const std::size_t control,
+                             const std::size_t target) {
+      u = cx.embedInNqubit(3, control, target) * u;
+    };
+
+    apply1(HOp::getUnitaryMatrix(), 2);
+    apply1(TOp::getUnitaryMatrix(), 2);
+    applyCx(1, 2);
+    apply1(TdgOp::getUnitaryMatrix(), 2);
+    applyCx(0, 2);
+    apply1(TOp::getUnitaryMatrix(), 2);
+    applyCx(1, 2);
+    apply1(TdgOp::getUnitaryMatrix(), 2);
+    apply1(HOp::getUnitaryMatrix(), 2);
+    return u;
+  }();
+  return unitary;
 }

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

static DynamicMatrix elementaryRCCXUnitary() {
  static const DynamicMatrix unitary = [] {
    constexpr Matrix4x4 cx =
        Matrix4x4::fromElements(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
                                0.0, 1.0, 0.0, 0.0, 1.0, 0.0);

    DynamicMatrix u = DynamicMatrix::identity(8);
    const auto apply1 = [&](const Matrix2x2& gate, const std::size_t qubit) {
      u = gate.embedInNqubit(3, qubit) * u;
    };
    const auto applyCx = [&](const std::size_t control,
                             const std::size_t target) {
      u = cx.embedInNqubit(3, control, target) * u;
    };

    apply1(HOp::getUnitaryMatrix(), 2);
    apply1(TOp::getUnitaryMatrix(), 2);
    applyCx(1, 2);
    apply1(TdgOp::getUnitaryMatrix(), 2);
    applyCx(0, 2);
    apply1(TOp::getUnitaryMatrix(), 2);
    applyCx(1, 2);
    apply1(TdgOp::getUnitaryMatrix(), 2);
    apply1(HOp::getUnitaryMatrix(), 2);
    return u;
  }();
  return unitary;
}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@mlir/lib/Dialect/QCO/IR/Operations/StandardGates/RCCXOp.cpp` around lines 18
- 42, Cache the result of elementaryRCCXUnitary in RCCXOp::getUnitaryMatrix
using a function-local static initialized by the existing computation, relying
on C++11 thread-safe magic statics. Ensure subsequent calls return the cached
constant DynamicMatrix without rebuilding it or performing repeated allocations
and multiplications.

mlir/lib/Dialect/QCO/Transforms/Decomposition/DecomposeMultiControlled.cpp (1)

76-78: 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Keep the decomposition within the promised {h, t, tdg, p, cx} basis.

The default min-controls=2 path emits RZOps through the CCPhase decomposition. Replace these balanced rz(±θ) calls with p(±θ); their global-phase differences cancel across each sequence.

Proposed fix

-  void rz(std::size_t q, double theta) {
-    setWire(q, RZOp::create(*builder_, loc_, wire(q), theta).getOutputQubit(0));
-  }
-
   void crz(std::size_t control, std::size_t target, double theta) {
     const double half = theta / 2.0;
-    rz(target, half);
+    p(target, half);
     cx(control, target);
-    rz(target, -half);
+    p(target, -half);
     cx(control, target);
   }
@@
-    rz(target, -quarter);
+    p(target, -quarter);
@@
-    rz(target, quarter);
+    p(target, quarter);
@@
-    rz(target, -quarter);
+    p(target, -quarter);
@@
-    rz(target, quarter);
+    p(target, quarter);

Also applies to: 109-115, 148-162

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@mlir/lib/Dialect/QCO/Transforms/Decomposition/DecomposeMultiControlled.cpp`
around lines 76 - 78, Update the CCPhase decomposition sequences, including the
default min-controls=2 path, to use the existing p operation for each balanced
±θ rotation instead of rz, including the additional occurrences in the related
decomposition blocks. Preserve the paired angles and sequence ordering so their
global-phase differences continue to cancel and the decomposition remains within
the {h, t, tdg, p, cx} basis.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

mlir/lib/Support/Passes.cpp (1)

36-41: 📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win

Revert the unrelated pass-runner cleanup.

These parameter renames and cleanup-pipeline diagnostic changes do not support multi-controlled decomposition. Keep them in a separate PR to avoid unrelated output and review churn.

As per coding guidelines, “Keep changes focused on the assigned task; do not perform unrelated cleanup, broad reformatting, dependency upgrades, or refactors without explicit authorization.”

Also applies to: 78-94, 121-141

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@mlir/lib/Support/Passes.cpp` around lines 36 - 41, Revert the unrelated
pass-runner cleanup in runWithPassManager and the affected code ranges,
restoring the original parameter names, formatting, and cleanup-pipeline
diagnostic behavior. Keep only changes required for multi-controlled
decomposition and do not alter pass-runner output or refactor surrounding code.

Source: Coding guidelines