✨ Add Constant Propagation

mlir/include/mlir/Dialect/QCO/Transforms/Passes.td

@@ -182,6 +182,42 @@ def MappingPass : Pass<"place-and-route", "mlir::ModuleOp"> {
 // Optimization Passes
 //===----------------------------------------------------------------------===//
 
+def ConstantPropagation : Pass<"constant-propagation", "mlir::ModuleOp"> {
+  let dependentDialects = ["mlir::qco::QCODialect",
+                           "::mlir::arith::ArithDialect"];
+  let summary = "This pass applies constant propagation to a circuit. It "
+                "assumes that all input qubits are |0>. It propagates the "
+                "state of the qubits up to a given complexity threshold and "
+                "removes gates which are superfluous considering the current "
+                "state.";
+  let description = [{
+     This pass applies quantum constant propagation. This optimization routine assumes that the input qubits of the
+     circuits are |0>. It propagates the qubit states and the state of additional classical values through the circuit.
+     All quantum instructions are removed which are superfluous considering the current state.
+
+     The qubit states and classical values are stored in hybrid states. Hybrid states are stored in a union table to
+     reduce the amount of complex amplitudes and classical values to track. There is a maximum number of non zero
+     amplitudes that is saved per union table entry. Additionally, there is also a maximum of hybrid states that can be
+     propagated. If the maximum number of amplitudes or the maximum number of hybrid states is exceeded, the propagated
+     state reaches top and no optimization routines are further applied.
+
+     The applied optimization routines are:
+
+     **General Control Reduction**
+     If a controlling qubit is always one, the control is removed.
+     If a controlling qubit is always zero, the complete gate is removed.
+
+  }];
+  let options = [Option<"maximumNonzeroAmplitudes",
+                        "maximum-nonzero-amplitudes", "std::size_t", "4",
+                        "The maximum number of non-zero amplitudes in the "
+                        "tracked quantum states before reaching top.">,
+                 Option<"maximumHybridStates", "maximum-hybrid-states",
+                        "std::size_t", "4",
+                        "The maximum number of hybrid states which have a "
+                        "non-zero probability.">];
+}
+
 def PauliTwirl2QGates : Pass<"pauli-twirl-2q-gates", "mlir::ModuleOp"> {
   let dependentDialects = ["mlir::qco::QCODialect",
                            "::mlir::arith::ArithDialect"];

mlir/lib/Dialect/QCO/Transforms/CMakeLists.txt

@@ -15,10 +15,15 @@ add_mlir_library(
   PUBLIC
   MQTCompilerTarget
   PRIVATE
+  MLIRAnalysis
+  MLIRControlFlowInterfaces
+  MLIRFunctionInterfaces
   MLIRQCODialect
   MLIRQCOUtils
+  MLIRQTensorDialect
   MLIRQTensorUtils
   MLIRArithDialect
+  MLIRFuncDialect
   MLIRMathDialect
   MLIRMQTDialect
   MLIRMQTTransforms

mlir/lib/Dialect/QCO/Transforms/Optimizations/ConstantPropagation.cpp

@@ -0,0 +1,98 @@
+/*
+ * 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
+ */
+
+#include "ConstantPropagation/ConstantPropagationAnalysis.hpp"
+#include "ConstantPropagation/Decisions.hpp"
+#include "ConstantPropagation/Rewriter.hpp"
+#include "mlir/Dialect/MQT/IR/MQTDialect.h"
+#include "mlir/Dialect/QCO/Transforms/Passes.h"
+
+#include <llvm/ADT/SmallVector.h>
+#include <mlir/Analysis/DataFlow/ConstantPropagationAnalysis.h>
+#include <mlir/Analysis/DataFlow/DeadCodeAnalysis.h>
+#include <mlir/Analysis/DataFlowFramework.h>
+#include <mlir/Dialect/Arith/IR/Arith.h>
+#include <mlir/Dialect/Func/IR/FuncOps.h>
+#include <mlir/IR/BuiltinOps.h>
+#include <mlir/IR/PatternMatch.h>
+
+namespace mlir::qco {
+
+#define GEN_PASS_DEF_CONSTANTPROPAGATION
+#include "mlir/Dialect/QCO/Transforms/Passes.h.inc"
+
+namespace {
+
+/**
+ * @brief Quantum constant propagation.
+ *
+ * Assumes every input qubit of the entry-point function starts in |0>,
+ * propagates the quantum/classical state through the circuit up to a complexity
+ * threshold (an MLIR `DenseForwardDataFlowAnalysis` over a `UnionTable`
+ * lattice), then removes operations that are superfluous given that state.
+ *
+ * Rewrites: delete a `qco.ctrl` whose controls can never all hold, and remove
+ * the always-satisfied controls from a `qco.ctrl` - rebuilding it with the
+ * rest, or inlining its body when every control was redundant. Analyze and
+ * rewrite alternate until a fixpoint because a removed gate can change a later
+ * gate's control facts. Classical controls are not reasoned about yet.
+ */
+struct ConstantPropagation final
+    : impl::ConstantPropagationBase<ConstantPropagation> {
+  using ConstantPropagationBase::ConstantPropagationBase;
+
+protected:
+  void runOnOperation() override {
+    ModuleOp module = getOperation();
+
+    func::FuncOp entry;
+    for (auto func : module.getOps<func::FuncOp>()) {
+      if (!mqt::isEntryPoint(func)) {
+        continue;
+      }
+      if (entry) {
+        module.emitError(
+            "constant propagation supports a single entry-point function");
+        return signalPassFailure();
+      }
+      entry = func;
+    }
+    if (!entry) {
+      return;
+    }
+
+    IRRewriter rewriter(&getContext());
+    constexpr unsigned maxRounds = 64;
+    for (unsigned round = 0; round < maxRounds; ++round) {
+      DataFlowSolver solver;
+      solver.load<dataflow::DeadCodeAnalysis>();
+      solver.load<dataflow::SparseConstantPropagation>();
+      solver.load<ConstantPropagationAnalysis>(maximumNonzeroAmplitudes,
+                                               maximumHybridStates);
+      if (failed(solver.initializeAndRun(module))) {
+        return signalPassFailure(); // the analysis emitted the diagnostic
+      }
+
+      const SmallVector<Decision> decisions = collectDecisions(entry, solver);
+      if (decisions.empty()) {
+        return; // fixpoint reached
+      }
+      applyDecisions(decisions, rewriter);
+    }
+
+    entry.emitError("constant propagation did not converge within ")
+        << maxRounds << " rounds";
+    signalPassFailure();
+  }
+};
+
+} // namespace
+
+} // namespace mlir::qco