Merge pull request #12 from SebVde/exact-deterministic

Exact deterministic

Author: SebVde

exact_mif.py

@@ -22,7 +22,7 @@ def get_cnf(G, T):
     components = list(nx.connected_components(nx.subgraph(G, T)))
 
     if len(components) > 0:
-        for v in set(G.nodes) - T:
+        for v in sorted(set(G.nodes) - T):
             # For each connected component from T, check if v has 2 or more neighbors in the component
             for comp in components:
                 neighbors_in_comp = set(nx.neighbors(G, v)) & comp  # & = intersection
@@ -126,17 +126,17 @@ def find_mif_len(G, T, K):
         v = None
         bnd = get_bnd(G, T)
         if len(bnd) > 0:
-            v = next(iter(bnd))
+            v = list(sorted(bnd))[0]
         else:
-            v = next(iter(set(G.nodes) - (T | K)))
+            v = list(sorted(set(G.nodes) - (T | K)))[0]
 
         new_G, new_T, new_K = T_update(G, T, K, v)
         new_S = find_mif_len(new_G, new_T, new_K)
 
         W = get_K_connected(G, K, v) & set(G.nodes) - (T | K | {v})
 
         match len(W):
-            case 0, 1:
+            case 0 | 1:
                 return new_S
             case 2:
                 sg = nx.subgraph(G, set(G.nodes) - {v})

exact_mif_v2.py

@@ -21,7 +21,7 @@ def construct_H(G, F, nb):
 
 
 def is_foldable(G, v):
-    nb = set(nx.neighbors(G, v))
+    nb = sorted(nx.neighbors(G, v))
     for x, y, z in itertools.combinations(nb, 3):
         if not (G.has_edge(x, y) or G.has_edge(y, z) or G.has_edge(z, x)):
             # If no edges between x-y-z, there is an anti-triangle so not foldable
@@ -31,7 +31,7 @@ def is_foldable(G, v):
 
 
 def get_anti_edges(G, v):
-    nb = set(nx.neighbors(G, v))
+    nb = nx.neighbors(G, v)
     anti_edges = set()
     for x, y in itertools.combinations(nb, 2):
         if not G.has_edge(x, y):
@@ -97,7 +97,7 @@ def get_max_indep_set(G):
 
         return res
 
-    for u, v in itertools.combinations(G.nodes, 2):
+    for u, v in itertools.combinations(sorted(G.nodes), 2):
         nb_u = set(nx.neighbors(G, u))
         nb_v = set(nx.neighbors(G, v))
         if (nb_v | {v}).issubset(nb_u | {u}):
@@ -168,7 +168,7 @@ def get_mif_len(G, F, active_v):
                 if connections > 1:
                     vertices_to_remove.add(v)
 
-            v_T = next(iter(T))
+            v_T = list(sorted(T))[0]
 
             for n in T - {v_T}:
                 new_G = nx.contracted_nodes(new_G, v_T, n, self_loops=False)
@@ -198,33 +198,33 @@ def main_procedure(G, F, active_v):
         if max_degree < 2:
             return len(G.nodes)
         else:
-            t = next(n for n, d in G.degree() if d >= 2)
+            t = list(sorted(n for n, d in G.degree() if d >= 2))[0]
             new_G = nx.subgraph(G, G.nodes - {t})
             return max(
                 get_mif_len(G, F | {t}, active_v), get_mif_len(new_G, F, active_v)
             )
 
     if active_v is None:
-        active_v = next(iter(F))
+        active_v = list(sorted(F))[0]
 
     nb = set(nx.neighbors(G, active_v))
     if set(G.nodes) - F == nb:
         return len(F) + get_max_indep_set(construct_H(G, F - {active_v}, nb))
 
-    for v in nb:
+    for v in sorted(nb):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         if len(gen_nb) < 2:
             return get_mif_len(G, F | {v}, active_v)
 
-    for v in nb:
+    for v in sorted(nb):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         if len(gen_nb) > 3:
             return max(
                 get_mif_len(G, F | {v}, active_v),
                 get_mif_len(nx.subgraph(G, G.nodes - {v}), F, active_v),
             )
 
-    for v in nb:
+    for v in sorted(nb):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         if len(gen_nb) == 2:
             return max(

exact_mif_v3.py

@@ -22,7 +22,7 @@ def get_non_trivial_components(G):
 
 
 def find_short_pair(G, F, active_v):
-    for u, v in itertools.combinations(set(G.nodes) - F, 2):
+    for u, v in itertools.combinations(sorted(set(G.nodes) - F), 2):
         nb_u = set(nx.neighbors(G, u))
         nb_v = set(nx.neighbors(G, v))
         # If parallel edges between u and v (so u,v is a short-cycle) or they have a common neighbor in F (also short-cycle)
@@ -37,18 +37,18 @@ def find_short_pair(G, F, active_v):
 
 def is_trigger_vertex(G, F, active_v, v):
     nb_active = set(nx.neighbors(G, active_v))
-    for u in nb_active - F:
+    for u in sorted(nb_active - F):
         gen_nb = get_generalized_neighbors(G, F, active_v, u)
         if len(gen_nb - nb_active) >= 3 and v in gen_nb:
             nb_v = set(nx.neighbors(G, v))
             nb_u = set(nx.neighbors(G, u))
             s_set = F - nb_v
             v_prime_set = F & nb_v
-            for s in s_set:
+            for s in sorted(s_set):
                 if nb_u == {active_v, v, s}:
                     return True
 
-                for v_prime in v_prime_set:
+                for v_prime in sorted(v_prime_set):
                     d_v_prime = G.degree(v_prime)
                     if d_v_prime == 2 and (
                         nb_u == {active_v, v_prime, s}
@@ -63,7 +63,7 @@ def find_optimal_v(G, F, active_v):
     nb_active = set(nx.neighbors(G, active_v))
     G_not_F = set(G.nodes) - F
     possible = set()
-    for v in G_not_F:
+    for v in sorted(G_not_F):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         if len(gen_nb) < 3:
             continue
@@ -101,7 +101,7 @@ def main_procedure(G, F, active_v):
 
     cut_v = set(nx.articulation_points(G))
     if len(cut_v) > 0:
-        v = next(iter(cut_v))
+        v = list(sorted(cut_v))[0]
         components = list(nx.connected_components(nx.subgraph(G, set(G.nodes) - {v})))
         H = min(components, key=lambda x: len(x))
 
@@ -143,10 +143,10 @@ def main_procedure(G, F, active_v):
         return max(get_mif_len(G, F | {v}, v), get_mif_len(new_G, F, active_v))
 
     if active_v is None:
-        active_v = next(iter(F))
+        active_v = list(sorted(F))[0]
 
     nb_active = set(nx.neighbors(G, active_v))
-    for v in nb_active:
+    for v in sorted(nb_active):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         d_v = G.degree(v)
 
@@ -156,7 +156,7 @@ def main_procedure(G, F, active_v):
                 get_mif_len(nx.subgraph(G, set(G.nodes) - {v}), F, active_v),
             )
 
-    for v in nb_active:
+    for v in sorted(nb_active):
         gen_nb = get_generalized_neighbors(G, F, active_v, v)
         if len(gen_nb) == 2:
             if not nx.is_forest(nx.subgraph(G, F | gen_nb)):
@@ -230,7 +230,7 @@ def get_mif_len(G, F, active_v):
         non_trivial_components = get_non_trivial_components(sg_F)
         if len(non_trivial_components) > 0:
             T = non_trivial_components[0]
-            v = next(iter(T))
+            v = list(sorted(T))[0]
             if (active_v is not None) and (active_v in T):
                 v = active_v
 
@@ -244,9 +244,9 @@ def get_mif_len(G, F, active_v):
         # Step 2
         v = None
         # If we find a node v not in new_F that has 2 parallel edges to a node u in new_F, we remove it from new_G
-        for n in set(new_G.nodes) - new_F:
+        for n in sorted(set(new_G.nodes) - new_F):
             nb_in_F = set(new_G.neighbors(n)) & new_F
-            for u in nb_in_F:
+            for u in sorted(nb_in_F):
                 if new_G.number_of_edges(u, n) > 1:
                     v = n
                     break