update merge rules

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -86,8 +86,7 @@ class OrbitGraphProcessor {
     };
 
     std::unordered_set<std::pair<VertexType, VertexType>, PairHasher> non_viable_edges_cache_;
-
-
+    std::unordered_set<std::pair<VertexType, VertexType>, PairHasher> non_viable_crit_path_edges_cache_;
 
     /**
      * @brief Simulates the merge of node v into u and returns the resulting temporary graph.
@@ -147,6 +146,22 @@ class OrbitGraphProcessor {
         }
         non_viable_edges_cache_ = std::move(next_non_viable_edges);
 
+
+        std::unordered_set<std::pair<VertexType, VertexType>, PairHasher> next_non_viable_crit_path_edges;
+        for (const auto &non_viable_edge : non_viable_crit_path_edges_cache_) {
+            VertexType old_u = non_viable_edge.first;
+            VertexType old_v = non_viable_edge.second;
+            // If an edge involved the removed vertex `v`, it's gone. Otherwise, remap its endpoints.
+            if (old_u != v && old_v != v) {
+                VertexType new_u = group_remap[old_u];
+                VertexType new_v = group_remap[old_v];
+                if (new_u != new_v) {
+                    next_non_viable_crit_path_edges.insert({new_u, new_v});
+                }
+            }
+        }
+        non_viable_crit_path_edges_cache_ = std::move(next_non_viable_crit_path_edges);
+
         std::vector<Group> next_groups(current_coarse_graph.num_vertices());
         for (VertexType i = 0; i < current_groups.size(); ++i) {
             if (i != u && i != v) {
@@ -243,7 +258,7 @@ class OrbitGraphProcessor {
         }
     }
 
-    void contract_edges(const Graph_t &original_dag, Constr_Graph_t& current_coarse_graph, std::vector<Group>& current_groups, std::vector<VertexType>& current_contraction_map, const bool merge_symmetry_narrowing, const bool merge_different_node_types) {
+    void contract_edges(const Graph_t &original_dag, Constr_Graph_t& current_coarse_graph, std::vector<Group>& current_groups, std::vector<VertexType>& current_contraction_map, const bool merge_symmetry_narrowing, const bool merge_different_node_types, const v_workw_t<Constr_Graph_t> work_threshold = 0) {
 
         bool changed = true;
         while (changed) {
@@ -258,7 +273,7 @@ class OrbitGraphProcessor {
                 VertexType v = target(edge, current_coarse_graph);
 
                 // Check memoization cache first
-                if (non_viable_edges_cache_.count({u, v})) {
+                if (non_viable_edges_cache_.count({u, v}) || non_viable_crit_path_edges_cache_.count({u, v})) {
                     continue;
                 }
 
@@ -290,8 +305,8 @@ class OrbitGraphProcessor {
                 const bool merge_viable = is_merge_viable(original_dag, current_groups[u], current_groups[v], new_subgraphs, error);
                 const bool both_below_symmetry_threshold =
                     (u_size < symmetry_threshold_) &&
-                    (v_size < symmetry_threshold_) && 
-                    (not ((u_size == 1 && v_size > 1) || (u_size > 1 && v_size == 1)));
+                    (v_size < symmetry_threshold_);// && 
+                    //  (not ((u_size == 1 && v_size > 1) || (u_size > 1 && v_size == 1)));
 
                 if (error) {
                     if constexpr (verbose) {
@@ -333,11 +348,12 @@ class OrbitGraphProcessor {
                 //     }
                 //     continue;
                 // }
-                if (critical_path_weight(temp_coarse_graph) > critical_path_weight(current_coarse_graph)) {
+                if (critical_path_weight(temp_coarse_graph) > (work_threshold * static_cast<v_workw_t<Constr_Graph_t>>(new_subgraphs.size()) + critical_path_weight(current_coarse_graph))) {
+                //if (critical_path_weight(temp_coarse_graph) > critical_path_weight(current_coarse_graph)) {
                     if constexpr (verbose) {
                         std::cout << "  - Merge of " << u << " and " << v << " increases critical path. Skipping.\n";
                     }
-                    non_viable_edges_cache_.insert({u, v});
+                    non_viable_crit_path_edges_cache_.insert({u, v});
                     continue;
                 }
 
@@ -378,6 +394,7 @@ class OrbitGraphProcessor {
         final_contraction_map_.clear();
         final_groups_.clear();
         non_viable_edges_cache_.clear();
+        non_viable_crit_path_edges_cache_.clear();
 
         if (dag.num_vertices() == 0) {
             return;
@@ -436,7 +453,9 @@ class OrbitGraphProcessor {
         if constexpr (verbose) {
             std::cout << "Attempting to merge small orbits.\n";
         }
-        merge_small_orbits(original_dag, current_coarse_graph, current_groups, current_contraction_map, work_threshold_);
+        non_viable_crit_path_edges_cache_.clear();
+        contract_edges(original_dag, current_coarse_graph, current_groups, current_contraction_map, true, true, work_threshold_);
+        // merge_small_orbits(original_dag, current_coarse_graph, current_groups, current_contraction_map, work_threshold_);
 
         // --- Finalize ---
         final_coarse_graph_ = std::move(current_coarse_graph);