Corrected determinism

Author: SebVde

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)
@@ -205,26 +205,26 @@ def main_procedure(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(