Fixed bug in mingenset lowerbound

Author: alexandrutomescu

examples/min_gen_set.py

@@ -32,6 +32,23 @@ def example2():
     mgs_solver.solve()
     process_solution(mgs_solver)
 
+def example3():
+    numbers = [2,4,6,7,9]
+    total=13
+    partition_constraints = []
+
+    mgs_solver = fp.MinGenSet(
+        numbers,
+        total=total,
+        weight_type=int,
+        partition_constraints=partition_constraints,
+        # remove_sums_of_two=False,
+        # remove_complement_values=False,
+        )
+    
+    mgs_solver.solve()
+    process_solution(mgs_solver)
+
 def process_solution(model: fp.MinGenSet):
     if model.is_solved():
         print(model.get_solution())
@@ -41,4 +58,5 @@ def process_solution(model: fp.MinGenSet):
 
 if __name__ == "__main__":
     example1()
-    example2()
+    example2()
+    example3()

flowpaths/kflowdecomp.py

@@ -164,8 +164,8 @@ def __init__(
 
         # Call the constructor of the parent class AbstractPathModelDAG
         super().__init__(
-            self.G, 
-            self.k,
+            G=self.G, 
+            k=self.k,
             subpath_constraints=self.subpath_constraints, 
             subpath_constraints_coverage=self.subpath_constraints_coverage, 
             subpath_constraints_coverage_length=self.subpath_constraints_coverage_length,
@@ -188,7 +188,7 @@ def __init__(
         # The given weights optimization
         self.__encode_given_weights()
 
-        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+        utils.logger.info(f"{__name__}: initialized with graph id = {utils.fpid(G)}, k = {self.k}")
 
     def __encode_flow_decomposition(self):
 

flowpaths/kleastabserrors.py

@@ -186,7 +186,7 @@ def __init__(
         # This method is called from the current class to add the objective function
         self.__encode_objective()
 
-        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+        utils.logger.info(f"{__name__}: initialized with graph id = {utils.fpid(G)}, k = {self.k}")
 
     def __encode_leastabserrors_decomposition(self):
 

flowpaths/kminpatherror.py

@@ -222,7 +222,7 @@ def __init__(
         # This method is called from the current class to add the objective function
         self.__encode_objective()
 
-        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}, k = {self.k}")
+        utils.logger.info(f"{__name__}: initialized with graph id = {utils.fpid(G)}, k = {self.k}")
 
     def __encode_minpatherror_decomposition(self):
 

flowpaths/minerrorflow.py

@@ -102,7 +102,7 @@ def __init__(
 
         self.__encode_objective()  
 
-        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}")  
+        utils.logger.info(f"{__name__}: initialized with graph id = {utils.fpid(G)}")  
 
     def __create_solver(self):
 

flowpaths/minflowdecomp.py

@@ -129,8 +129,9 @@ def __init__(
         self.__generating_set = None
         self.__all_subgraph_weights = None
         self.__given_weights_model = None
+        self.__source_flow = None
 
-        utils.logger.info(f"{__name__}: initialized with graph id = {id(G)}")
+        utils.logger.info(f"{__name__}: initialized with graph id = {utils.fpid(G)}")
 
     def solve(self) -> bool:
         """
@@ -236,6 +237,21 @@ def __solve_with_given_weights(self) -> bool:
             self.__given_weights_model = given_weights_kfd_solver
             sol = self.__given_weights_model.get_solution(remove_empty_paths=True)
             utils.logger.info(f"{__name__}: found an MFD solution with given weights in {len(sol['paths'])} paths weights {sol['weights']}")
+        else:
+            utils.logger.info(f"{__name__}: did NOT found an MFD solution with given weights")
+
+    def __get_source_flow(self):
+        if self.__source_flow is None:
+            self.__source_flow = 0
+            for v in self.G.nodes():
+                if self.G.in_degree(v) == 0:
+                    for _, _, data in self.G.out_edges(v, data=True):
+                        if self.flow_attr in data:
+                            self.__source_flow += data[self.flow_attr]
+            utils.logger.debug(f"{__name__}: source_flow = {self.__source_flow}")
+            return self.__source_flow
+        else:
+            return self.__source_flow
 
     def __get_partition_constraints_for_min_gen_set(
             self, 
@@ -271,7 +287,7 @@ def __get_partition_constraints_for_min_gen_set(
             for i in range(level[u], level[v]):
                 level_edges[i].append((u, v))
 
-        source_flow = sum(self.G.nodes[n].get(self.flow_attr, 0) for n in self.G.nodes() if self.G.in_degree(n) == 0)
+        source_flow = self.__get_source_flow()
 
         # Now we create the partition constraints
         for i in range(max_level):
@@ -306,7 +322,10 @@ def __get_lowerbound_with_min_gen_set(self) -> int:
 
         start_time = time.time()
         all_weights = list(set({self.G.edges[e][self.flow_attr] for e in self.G.edges() if self.flow_attr in self.G.edges[e]}))
-        source_flow = sum(self.G.nodes[n].get(self.flow_attr, 0) for n in self.G.nodes() if self.G.in_degree(n) == 0)
+        # Get the source_flow as the sum of the flow values on all the edges exiting the source nodes
+        # (i.e., nodes with in-degree 0)
+        source_flow = self.__get_source_flow()
+        # source_flow = sum(self.G.nodes[n].get(self.flow_attr, 0) for n in self.G.nodes() if self.G.in_degree(n) == 0)
         current_lowerbound_k = self.__lowerbound_k if self.__lowerbound_k is not None else 1
         min_gen_set_lowerbound = None
 
@@ -332,6 +351,9 @@ def __get_lowerbound_with_min_gen_set(self) -> int:
             self.__generating_set = mingenset_model.get_solution()
             min_gen_set_lowerbound = len(self.__generating_set)
             utils.logger.info(f"{__name__}: found a min gen set solution with {min_gen_set_lowerbound} elements ({self.__generating_set})")
+        else:
+            utils.logger.info(f"{__name__}: did NOT find a min gen set solution")
+            exit(0)
 
         self.solve_statistics["min_gen_set_solve_time"] = time.time() - start_time
 

flowpaths/mingenset.py

@@ -1,4 +1,5 @@
 import flowpaths.utils.solverwrapper as sw
+import flowpaths.utils as utils
 import time
 
 class MinGenSet():
@@ -65,8 +66,10 @@ def __init__(
         """
 
         self.numbers = list(numbers) # Make a copy of the list
+        utils.logger.debug(f"{__name__}: Initial numbers: {self.numbers}")
         self.initial_numbers = numbers
         self.total = total
+        utils.logger.debug(f"Total: {self.total}")
         self.weight_type = weight_type
         self.lowerbound = lowerbound
         self.partition_constraints = partition_constraints
@@ -98,6 +101,8 @@ def __init__(
 
             self.numbers = list(set(self.numbers) - elements_to_remove)
 
+        utils.logger.debug(f"{__name__}: Numbers after removing values: {self.numbers}")
+
     def __create_solver(self, k):
 
         self.solver = sw.SolverWrapper()

flowpaths/utils/__init__.py

@@ -2,6 +2,7 @@
 from .graphutils import max_bottleneck_path
 from .graphutils import check_flow_conservation
 from .graphutils import draw_solution
+from .graphutils import fpid
 from .logging import configure_logging
 from .logging import logger
 
@@ -12,4 +13,5 @@
     "draw_solution",
     "configure_logging",
     "logger",
+    "fpid"
 ]

flowpaths/utils/graphutils.py

@@ -3,6 +3,16 @@
 
 bigNumber = 1 << 32
 
+def fpid(G) -> str:
+    """
+    Returns a unique identifier for the given graph.
+    """
+    if isinstance(G, nx.DiGraph):
+        if "id" in G.graph:
+            return G.graph["id"]
+
+    return str(id(G))
+
 def read_graph(graph_raw) -> nx.DiGraph:
     # Input format is: ['#Graph id\n', 'n\n', 'u_1 v_1 w_1\n', ..., 'u_k v_k w_k\n']
     id = graph_raw[0].strip("# ").strip()
@@ -22,7 +32,7 @@ def read_graph(graph_raw) -> nx.DiGraph:
         # print(elements)
         u = elements[0].strip()
         v = elements[1].strip()
-        w = int(elements[2].strip(" \n"))
+        w = float(elements[2].strip(" \n"))
         # print(u, v, w)
         G.add_edge(u, v, flow=w)