alonso 0.0.7__tar.gz → 0.0.9__tar.gz

{alonso-0.0.7 → alonso-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.7
+Version: 0.0.9
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -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 $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $O(n^3)$, 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)$.
+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)$), checking for claw-free in $\mathcal{O}(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $\mathcal{O}(n^3)$, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n \cdot \log n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursion depth never exceeds a small constant, most commonly 2. This yields a total runtime of $\mathcal{O}(n^3)$, per a constant time of recursion levels.
 
 ---
 

{alonso-0.0.7 → alonso-0.0.9}/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 $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $O(n^3)$, 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)$.
+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)$), checking for claw-free in $\mathcal{O}(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $\mathcal{O}(n^3)$, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n \cdot \log n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursion depth never exceeds a small constant, most commonly 2. This yields a total runtime of $\mathcal{O}(n^3)$, per a constant time of recursion levels.
 
 ---
 

{alonso-0.0.7 → alonso-0.0.9}/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.7')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.9')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.7 → alonso-0.0.9}/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.7')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.9')
 
     
     # Initialize the parameters

{alonso-0.0.7 → alonso-0.0.9}/alonso/partition.py

@@ -1,7 +1,8 @@
 from collections import defaultdict
 import networkx as nx
 from typing import Set, Tuple, List
-import mendive.algorithm as algo
+import mendive.algorithm as claws
+import aegypti.algorithm as triangles
 class ClawFreePartitioner:
     """
     Implements a polynomial-time algorithm to partition graph edges into two sets
@@ -57,32 +58,23 @@ class ClawFreePartitioner:
             True if adding the edge would create a claw, False otherwise
         """
         # Build adjacency list for current partition
-        adj = defaultdict(set)
+        G = nx.Graph()
         for u, v in edges_in_partition:
-            adj[u].add(v)
-            adj[v].add(u)
+            G.add_edge(u, v)
         
         # Add the new edge temporarily
         u, v = new_edge
-        adj[u].add(v)
-        adj[v].add(u)
-        
+        G.add_edge(u, v)
+        H = nx.complement(G)
         # Check if any vertex now forms a claw
         for vertex in [u, v]:
-            neighbors = list(adj[vertex])
+            neighbors = list(G.neighbors(vertex))
             if len(neighbors) >= 3:
                 # Check all combinations of 3 neighbors
-                
-                for i in range(len(neighbors)):
-                    for j in range(i + 1, len(neighbors)):
-                        for k in range(j + 1, len(neighbors)):
-                            n1, n2, n3 = neighbors[i], neighbors[j], neighbors[k]
-                            # Check if these 3 neighbors are not connected to each other
-                            # (which would make vertex the center of a claw)
-                            if (n1 not in adj[n2] and n2 not in adj[n1] and
-                                n1 not in adj[n3] and n3 not in adj[n1] and
-                                n2 not in adj[n3] and n3 not in adj[n2]):
-                                return True
+                subgraph = H.subgraph(neighbors)
+                triangle = triangles.find_triangle_coordinates(subgraph, first_triangle=True)
+                if triangle is not None:
+                    return True
         
         return False
     
@@ -162,7 +154,7 @@ class ClawFreePartitioner:
         # Build adjacency list
         G = nx.Graph()
         G.add_edges_from(edge_set)
-        claw = algo.find_claw_coordinates(G, first_claw=True)
+        claw = claws.find_claw_coordinates(G, first_claw=True)
         if claw is None:
             return True
         else: 

{alonso-0.0.7 → alonso-0.0.9}/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.7')
+    helper.add_argument('--version', action='version', version='%(prog)s 0.0.9')
     
     # Initialize the parameters
     args = helper.parse_args()

{alonso-0.0.7 → alonso-0.0.9}/alonso.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alonso
-Version: 0.0.7
+Version: 0.0.9
 Summary: Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.
 Home-page: https://github.com/frankvegadelgado/alonso
 Author: Frank Vega
@@ -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 $O(n + m)$), checking for claw-free in $O(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $O(n^3)$, 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)$.
+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)$), checking for claw-free in $\mathcal{O}(m \cdot \Delta)$ where $\Delta$ is the maximum degree, partitions edges in $\mathcal{O}(n^3)$, computes vertex covers in $\mathcal{O}(n^3)$ per subgraph (total $\mathcal{O}(n^3)$), merges covers in $\mathcal{O}(n \cdot \log n)$, and constructs the residual graph in $\mathcal{O}(m)$. The recursion depth never exceeds a small constant, most commonly 2. This yields a total runtime of $\mathcal{O}(n^3)$, per a constant time of recursion levels.
 
 ---
 

{alonso-0.0.7 → alonso-0.0.9}/setup.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import setuptools
 
-VERSION = "0.0.7"
+VERSION = "0.0.9"
 
 NAME = "alonso"