alonso 0.0.3__tar.gz → 0.0.5__tar.gz

{alonso-0.0.3 → alonso-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.3
+Version: 0.0.5
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -22,7 +22,7 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mendive>=0.0.4
+Requires-Dist: mendive>=0.0.5
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -69,7 +69,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

{alonso-0.0.3 → alonso-0.0.5}/README.md

@@ -31,7 +31,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

{alonso-0.0.3 → alonso-0.0.5}/alonso/algorithm.py

@@ -24,54 +24,52 @@ def find_vertex_cover(graph):
     # Validate that the input is a valid undirected NetworkX graph
     if not isinstance(graph, nx.Graph):
         raise ValueError("Input must be an undirected NetworkX Graph.")
-    
+
     # Handle trivial cases: return empty set for graphs with no nodes or no edges
     if graph.number_of_nodes() == 0 or graph.number_of_edges() == 0:
         return set()  # No vertices or edges mean no cover is needed
-    
+
     # Create a working copy to avoid modifying the original graph
     working_graph = graph.copy()
-    
+
     # Remove self-loops as they are irrelevant for vertex cover computation
     working_graph.remove_edges_from(list(nx.selfloop_edges(working_graph)))
-    
+
     # Remove isolated nodes (degree 0) since they don't contribute to the vertex cover
     working_graph.remove_nodes_from(list(nx.isolates(working_graph)))
-    
+
     # Return empty set if the cleaned graph has no nodes after removals
     if working_graph.number_of_nodes() == 0:
         return set()
-    
-    # Structural analysis: detect presence of claw subgraphs (K_{1,3})
+
+    # Structural analysis: detect presence of claw subgraphs
     # This determines which algorithmic approach to use
     claw = algo.find_claw_coordinates(working_graph, first_claw=True)
-   
+
     if claw is None:
         # CASE 1: Claw-free graph - use polynomial-time exact algorithm
         # Apply Faenza-Oriolo-Stauffer algorithm for weighted stable set on claw-free graphs
         # The maximum weighted stable set's complement gives us the minimum vertex cover
         E = working_graph.edges()
         approximate_vertex_cover = stable.minimum_vertex_cover_claw_free(E)
-        
+
     else:
         # CASE 2: Graph contains claws - use divide-and-conquer approach
-        
-        # Step 1: Edge partitioning using enhanced Burr-Erdős-Lovász technique
-        # Partition edges E = E1 ∪ E2 such that both induced subgraphs G[E1] and G[E2] are claw-free
-        # Complexity: O(m * (m * Δ * C + C^2)), where m is edges, Δ is maximum degree, C is number of claws
+
+        # Step 1: Edge partitioning using enhanced Burr-Erdos-Lovasz technique
+        # Partition edges E = E1 union E2 such that both induced subgraphs G[E1] and G[E2] are claw-free
         E1, E2 = partition.partition_edges_claw_free(working_graph)
-       
+
         # Step 2: Solve subproblems optimally on claw-free partitions
         # Each partition can be solved exactly using polynomial-time algorithms
-        vertex_cover_1 = stable.minimum_vertex_cover_claw_free(E1)  # O(n^3) for subgraph G[E1]
-        vertex_cover_2 = stable.minimum_vertex_cover_claw_free(E2)  # O(n^3) for subgraph G[E2]
-        
-        # Step 3: Intelligent merging with 1.42-approximation guarantee
-        # Time complexity: O(|V| × log |V|)
+        vertex_cover_1 = stable.minimum_vertex_cover_claw_free(E1)
+        vertex_cover_2 = stable.minimum_vertex_cover_claw_free(E2)
+
+        # Step 3: Intelligent merging with 1.9-approximation guarantee
         approximate_vertex_cover = merge.merge_vertex_covers(
             working_graph, vertex_cover_1, vertex_cover_2
         )
-       
+
         # Step 4: Handle residual uncovered edges through recursion
         # Construct residual graph containing edges missed by current vertex cover
         residual_graph = nx.Graph()
@@ -79,14 +77,14 @@ def find_vertex_cover(graph):
             # Edge (u,v) is uncovered if neither endpoint is in our current cover
             if u not in approximate_vertex_cover and v not in approximate_vertex_cover:
                 residual_graph.add_edge(u, v)
-       
+
         # Recursive call to handle remaining uncovered structure
         # This ensures completeness: every edge in the original graph is covered
         residual_vertex_cover = find_vertex_cover(residual_graph)
-        
+
         # Combine solutions: union of main cover and residual cover
         approximate_vertex_cover = approximate_vertex_cover.union(residual_vertex_cover)
-   
+
     return approximate_vertex_cover
 
 def find_vertex_cover_brute_force(graph):

{alonso-0.0.3 → alonso-0.0.5}/alonso/app.py

@@ -82,7 +82,7 @@ def main():
     helper.add_argument('-c', '--count', action='store_true', help='calculate the size of the vertex cover')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.3')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.5')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.3 → alonso-0.0.5}/alonso/batch.py

@@ -36,7 +36,7 @@ def main():
     helper.add_argument('-c', '--count', action='store_true', help='calculate the size of the vertex cover')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.3')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.5')
 
     
     # Initialize the parameters

{alonso-0.0.3 → alonso-0.0.5}/alonso/test.py

@@ -34,7 +34,7 @@ def main():
     helper.add_argument('-w', '--write', action='store_true', help='write the generated random matrix to a file in the current directory')
     helper.add_argument('-v', '--verbose', action='store_true', help='anable verbose output')
     helper.add_argument('-l', '--log', action='store_true', help='enable file logging')
-    helper.add_argument('--version', action='version', version='%(prog)s 0.0.3')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.5')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.3 → alonso-0.0.5}/alonso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.3
+Version: 0.0.5
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -22,7 +22,7 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: mendive>=0.0.4
+Requires-Dist: mendive>=0.0.5
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -69,7 +69,7 @@ Given an undirected graph $G = (V, E)$, a **vertex cover** is a subset $V' \subs
 
 # Overview of the Algorithm and Its Running Time
 
-The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $\mathcal{O}(n + m)$), partitions edges in $\mathcal{O}(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursive nature, with a worst-case depth of $\mathcal{O}(m)$ if each step covers one edge, yields a total runtime of $\mathcal{O}(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = \mathcal{O}(n)$), this simplifies to $\mathcal{O}(n^4)$.
+The `find_vertex_cover` algorithm approximates a minimum vertex cover for an undirected graph $G = (V, E)$ by partitioning its edges into two claw-free subgraphs using the Burr-Erdős-Lovász (1976) method, computing exact vertex covers for these subgraphs with the Faenza, Oriolo, and Stauffer (2011) approach, and recursively refining the solution on residual edges. This process prevents the ratio from reaching 2, leveraging overlap between subgraphs and minimal additions in recursion. The algorithm begins by cleaning the graph (removing self-loops and isolates in $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$, partitions edges in $O(m \cdot (m \cdot \Delta \cdot C + C^2))$ where $\Delta$ is the maximum degree and $C$ is the number of claws, computes vertex covers in $O(n^3)$ per subgraph (total $O(n^3)$), merges covers in $O(n \cdot \log n)$, and constructs the residual graph in $O(m)$. The recursive nature, with a worst-case depth of $O(m)$ if each step covers one edge, yields a total runtime of $O(n^3 m)$, dominated by the cubic cost across levels. For sparse graphs ($m = O(n)$), this simplifies to $O(n^4)$.
 
 ---
 

alonso-0.0.5/alonso.egg-info/requires.txt

@@ -0,0 +1 @@
+mendive>=0.0.5

{alonso-0.0.3 → alonso-0.0.5}/setup.py

@@ -2,12 +2,12 @@ from pathlib import Path
 
 import setuptools
 
-VERSION = "0.0.3"
+VERSION = "0.0.5"
 
 NAME = "alonso"
 
 INSTALL_REQUIRES = [
-    "mendive>=0.0.4",
+    "mendive>=0.0.5",
 ]
 
 setuptools.setup(

alonso-0.0.3/alonso.egg-info/requires.txt

@@ -1 +0,0 @@
-mendive>=0.0.4