migrate pass & solver to ID

Author: kipawaa

doc/releases/changelog-dev.md

@@ -313,6 +313,7 @@
   [(#2983)](https://github.com/PennyLaneAI/catalyst/pull/2983)
   [(#3022)](https://github.com/PennyLaneAI/catalyst/pull/3022)
   [(#3039)](https://github.com/PennyLaneAI/catalyst/pull/3039)
+  [(#3046)](https://github.com/PennyLaneAI/catalyst/pull/3046)
 
 * The `graph-decomposition` pass eliminates three redundant IR manipulations:
   the cloning, removal, and re-insertion of user rules. This optimization is particularly

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGBuilder.cpp

@@ -18,13 +18,23 @@
 
 #include "DGBuilder.hpp"
 
+#include <cstddef>
 #include <cstdint>
 #include <iostream>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 #include <variant>
+#include <vector>
 
-#include "DGUtils.hpp"
+#include "boost/graph/adjacency_list.hpp"
+#include "boost/graph/detail/adjacency_list.hpp"
+#include "boost/graph/graph_selectors.hpp"
+#include "boost/graph/graph_traits.hpp"
 
-#include <boost/graph/adjacency_list.hpp>
+#include "DGTypes.hpp"
+#include "DGUtils.hpp"
 
 using namespace DecompGraph::Core;
 

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGBuilder.hpp

@@ -24,6 +24,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <memory>
 #include <vector>
 

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGSolver.cpp

@@ -18,12 +18,14 @@
 
 #include "DGSolver.hpp"
 
-#include <algorithm>
 #include <optional>
+#include <string>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "DGTypes.hpp"
+#include "DGUtils.hpp"
 
 using namespace DecompGraph::Core;
 

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGSolver.hpp

@@ -25,14 +25,12 @@
 
 #pragma once
 
-#include <optional>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "DGBuilder.hpp"
 #include "DGTypes.hpp"
-#include "DGUtils.hpp"
 
 namespace DecompGraph::Solver {
 

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGTypes.hpp

@@ -53,39 +53,16 @@ namespace DecompGraph::Core {
  * when adding support for operators with dynamic numbers of wires/params.
  */
 struct OperatorNode {
-    std::string name;
-    int numWires{-1};
-    int numParams{-1};
+    std::string id;
     bool adjoint{false};
 
-    // Optional static arguments for operators that require additional data.
+    // optional params, primarily for debug use
+    std::string name{""};
+    int numWires{-1};
+    int numParams{-1};
     std::unordered_map<std::string, std::string> staticNamedArgs{};
-    std::string id{""};
 
-    bool operator==(const OperatorNode &other) const
-    {
-        // id match
-        if (!id.empty() && !other.id.empty() && id == other.id) {
-            return true;
-        }
-        // legacy fallback if either op is missing ID
-
-        // For equality, we consider numWires and numParams conditionally equal
-        // if they are not set to -1 (which indicates a wildcard that can match any value).
-        const bool default_wires =
-            (numWires == -1 || other.numWires == -1 || numWires == other.numWires);
-        const bool default_params =
-            (numParams == -1 || other.numParams == -1 || numParams == other.numParams);
-
-        // Static arguments are optional: if either side has no static args, they
-        // are treated as matching (wildcard). When both sides provide entries, the maps must
-        // be equal element-wise for the operators to be considered equivalent.
-        const bool static_args_match = staticNamedArgs.empty() || other.staticNamedArgs.empty() ||
-                                       staticNamedArgs == other.staticNamedArgs;
-
-        return name == other.name && default_wires && default_params && adjoint == other.adjoint &&
-               static_args_match;
-    }
+    bool operator==(const OperatorNode &other) const { return id == other.id; }
     bool operator!=(const OperatorNode &other) const { return !(*this == other); }
 };
 
@@ -107,45 +84,24 @@ struct OperatorNode {
 struct OperatorNodeHash {
     std::size_t operator()(const OperatorNode &node) const
     {
-        // prefer id if available
-        if (!node.id.empty()) {
-            return std::hash<std::string>{}(node.id);
-        }
-        return std::hash<std::string>{}(node.name);
+        return std::hash<std::string>{}(node.id);
     }
 };
 
 /**
  * @brief This represents the weighted target gateset for the graph decomposition problem.
  */
 struct WeightedGateset {
+    // TODO: using ID here mandates that gatesets specify all legal IDs, rather than generic class
+    // like "PauliRot". This should be updated to work on generic names
     std::unordered_map<OperatorNode, double, OperatorNodeHash> ops;
 
-    [[nodiscard]] bool contains(const OperatorNode &op) const
-    {
-        // hash match
-        if (ops.find(op) != ops.end()) {
-            return true;
-        }
-
-        // use op-matching if hashes failed (could be id vs name)
-        for (auto [gatesetOp, cost] : ops) {
-            if (gatesetOp == op) {
-                return true;
-            }
-        }
-
-        return false;
-    }
+    [[nodiscard]] bool contains(const OperatorNode &op) const { return ops.find(op) != ops.end(); }
 
     [[nodiscard]] double getCost(const OperatorNode &op) const
     {
         auto it = ops.find(op);
-        if (it != ops.end()) {
-            return it->second;
-        }
-
-        return std::numeric_limits<double>::infinity();
+        return it != ops.end() ? it->second : std::numeric_limits<double>::infinity();
     }
 };
 

mlir/lib/Quantum/Transforms/GraphDecomposition/DecompGraphSolver/DGUtils.hpp

@@ -25,6 +25,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "DGTypes.hpp"

mlir/lib/Quantum/Transforms/GraphDecomposition/graph_decomposition.cpp

@@ -422,28 +422,16 @@ struct GraphDecompositionPass : public impl::GraphDecompositionPassBase<GraphDec
         // dialect.
         // The interface will provide one unified way of generating operator nodes from operations,
         // with consistent getter methods for all relevant data fields.
-        getOperation().walk([&](quantum::QuantumGate op) {
+        getOperation().walk([&](DecomposableGate op) {
             if (DecompUtils::isInDecompRule(op)) {
                 return;
             }
             OperatorNode node;
             node.numWires = op.getNonCtrlQubitOperands().size();
             node.adjoint = op.getAdjointFlag();
 
-            if (auto customOp = llvm::dyn_cast<quantum::CustomOp>(op.getOperation())) {
-                node.name = customOp.getGateName().str();
-            }
-            // Name handling for non-custom ops
-            else {
-                std::string name = op->getName().stripDialect().str();
-                if (name == "gphase") {
-                    name = "GlobalPhase";
-                }
-                else if (name == "paulirot") {
-                    name = cast<DecomposableGate>(op.getOperation()).getGraphOpId();
-                }
-                node.name = name;
-            }
+            node.name = op.getOperatorName();
+            node.id = op.getGraphOpId();
 
             if (auto paramOp =
                     llvm::dyn_cast<catalyst::quantum::ParametrizedGate>(op.getOperation())) {
@@ -453,10 +441,6 @@ struct GraphDecompositionPass : public impl::GraphDecompositionPassBase<GraphDec
                 node.numParams = 0;
             }
 
-            if (auto decompGate = dyn_cast<DecomposableGate>(op.getOperation())) {
-                node.id = decompGate.getGraphOpId();
-            }
-
             operators.push_back(node);
         });
     }