revise bwd merkle hash computer, orbit error

Author: tonibohnlein

include/osp/dag_divider/isomorphism_divider/MerkleHashComputer.hpp

@@ -24,6 +24,7 @@ limitations under the License.
 #include <stdexcept> 
 #include "osp/concepts/computational_dag_concept.hpp"
 #include "osp/graph_algorithms/directed_graph_top_sort.hpp"
+#include "osp/graph_algorithms/directed_graph_util.hpp"
 #include "osp/auxiliary/hash_util.hpp"
 
 namespace osp {
@@ -160,19 +161,15 @@ template<typename Graph_t>
 struct bwd_merkle_node_hash_func {
 
     MerkleHashComputer<Graph_t, uniform_node_hash_func<vertex_idx_t<Graph_t>>, false> bw_merkle_hash;
+    std::vector<std::size_t> vertex_components;
 
-    const Graph_t & graph_;
-
-    bwd_merkle_node_hash_func(const Graph_t & graph) : bw_merkle_hash(graph), graph_(graph) {}
+    bwd_merkle_node_hash_func(const Graph_t & graph) : bw_merkle_hash(graph) {
+        compute_weakly_connected_components(graph, vertex_components);
+    }
 
     std::size_t operator()(const vertex_idx_t<Graph_t> & v) const {
         std::size_t hash = bw_merkle_hash.get_vertex_hash(v);
-        hash_combine(hash, graph_.vertex_work_weight(v));
-        
-        if constexpr (has_typed_vertices_v<Graph_t>) {
-            hash_combine(hash, graph_.vertex_type(v));
-        }
-
+        hash_combine(hash, static_cast<size_t>((vertex_components[v] + 3) * 7));
         return hash;
     }
 };

include/osp/dag_divider/isomorphism_divider/OrbitGraphProcessor.hpp

@@ -163,9 +163,15 @@ class OrbitGraphProcessor {
 
                 // --- Check Constraints ---
                 // Symmetry Threshold
-                const bool merge_viable = is_merge_viable(original_dag, current_groups[u], current_groups[v], new_subgraphs);
+                bool error = false;
+                const bool merge_viable = is_merge_viable(original_dag, current_groups[u], current_groups[v], new_subgraphs, error);
                 const bool both_below_symmetry_threshold = (current_groups[u].size() < symmetry_threshold_) && (current_groups[v].size() < symmetry_threshold_);// && (not ((current_groups[u].size() == 1 && current_groups[v].size() > 1) || (current_groups[u].size() > 1 && current_groups[v].size() == 1)));
 
+                if (error) {
+                    if constexpr (verbose) { std::cout << "  - Merge of " << u << " and " << v << " and " << v << " not viable (error in is_merge_viable)\n"; }
+                    continue;
+                }
+
                 if (!merge_viable && !both_below_symmetry_threshold) {
                     if constexpr (verbose) { std::cout << "  - Merge of " << u << " and " << v << " not viable (symmetry threshold)\n"; }
                     continue;
@@ -261,7 +267,7 @@ class OrbitGraphProcessor {
      * If viable, it populates the `out_new_subgraphs` with the structure of the merged group.
      */
     bool is_merge_viable(const Graph_t& original_dag, const Group& group_u, const Group& group_v,
-                         std::vector<std::vector<VertexType>>& out_new_subgraphs) const {
+                         std::vector<std::vector<VertexType>>& out_new_subgraphs, bool & error) const {
 
         std::vector<VertexType> all_nodes;
         all_nodes.reserve(group_u.subgraphs.size() + group_v.subgraphs.size());
@@ -281,13 +287,19 @@ class OrbitGraphProcessor {
         std::sort(all_nodes.begin(), all_nodes.end());
 
         Constr_Graph_t induced_subgraph;
-        auto map = create_induced_subgraph_map(original_dag, induced_subgraph, all_nodes);
 
+        // create_induced_subgraph(original_dag, induced_subgraph, all_nodes);
+        // std::vector<VertexType> components; // local -> component_id
+        // size_t num_components = compute_weakly_connected_components(induced_subgraph, components);
+        // out_new_subgraphs.assign(num_components, std::vector<VertexType>());
+        // for (VertexType i = 0; i < induced_subgraph.num_vertices(); ++i) {
+        //     out_new_subgraphs[components[i]].push_back(all_nodes[i]);
+        // }
+
+        auto map = create_induced_subgraph_map(original_dag, induced_subgraph, all_nodes);
         std::vector<VertexType> components; // local -> component_id
         size_t num_components = compute_weakly_connected_components(induced_subgraph, components);
-
         out_new_subgraphs.assign(num_components, std::vector<VertexType>());
-
         for (const auto & node : all_nodes) {
             out_new_subgraphs[components[map[node]]].push_back(node);
         }
@@ -303,12 +315,14 @@ class OrbitGraphProcessor {
 
             for (size_t i = 1; i < num_components; ++i) {
                 if (out_new_subgraphs[i].size() != first_sg_size) {
+                    error = true;
                     return false;
                 }
 
                 Constr_Graph_t current_sg;
                 create_induced_subgraph(original_dag, current_sg, out_new_subgraphs[i]);
                 if (!are_isomorphic_by_merkle_hash(rep_sg, current_sg)) {
+                    error = true;
                     return false;
                 }
             }