alonso 0.0.1__py3-none-any.whl

alonso/partition.py

@@ -0,0 +1,216 @@
+import networkx as nx
+from typing import Tuple, Set, List
+from collections import defaultdict
+import itertools
+import mendive.algorithm as claws
+
+class BurrErdosLovaszPartitioner:
+    """
+    Implementation of the Burr-Erdős-Lovász (1976) algorithm for partitioning
+    edges of a graph into two subsets such that each subset induces a k-star-free subgraph.
+    
+    For k=3 (claw-free case), we partition edges to avoid 3-stars in each partition.
+    
+    The algorithm works by maintaining two edge sets and for each new edge,
+    assigning it to the partition where it creates the fewest violations,
+    then locally repairing any violations that arise.
+    """
+    
+    def __init__(self, graph: nx.Graph, k: int = 3):
+        self.graph = graph.copy()
+        self.k = k  # k=3 for claw-free (3-star-free)
+        self.n = len(graph.nodes())
+        
+    def partition_edges(self) -> Tuple[Set[Tuple[int, int]], Set[Tuple[int, int]]]:
+        """
+        Partition edges into two k-star-free subgraphs using BEL algorithm.
+        """
+        E1 = set()
+        E2 = set()
+        
+        # Convert edges to consistent format
+        edges = [(min(u, v), max(u, v)) for u, v in self.graph.edges()]
+        
+        # Main algorithm: assign each edge to minimize violations
+        for edge in edges:
+            # Count violations if we add edge to E1
+            violations_E1 = self._count_violations_after_adding(E1, edge)
+            violations_E2 = self._count_violations_after_adding(E2, edge)
+            
+            # Add to partition with fewer violations
+            if violations_E1 <= violations_E2:
+                E1.add(edge)
+                # Repair violations in E1
+                E1 = self._repair_violations(E1)
+            else:
+                E2.add(edge)
+                # Repair violations in E2
+                E2 = self._repair_violations(E2)
+        
+        return E1, E2
+    
+    def _count_violations_after_adding(self, edge_set: Set[Tuple[int, int]], 
+                                     new_edge: Tuple[int, int]) -> int:
+        """Count number of k-stars that would be created by adding new_edge."""
+        temp_set = edge_set | {new_edge}
+        return self._count_k_stars(temp_set)
+    
+    def _is_claw_free(self, edge_set: Set[Tuple[int, int]]) -> bool:
+        """Count number of k-stars in the edge set."""
+        if not edge_set:
+            return True
+            
+        # Build graph from edge set
+        G = nx.Graph()
+        G.add_edges_from(edge_set)
+        
+        claw = claws.find_claw_coordinates(G, first_claw=True)
+        if claw is None:
+            return True
+        else:
+            return False
+    
+    
+    def _count_k_stars(self, edge_set: Set[Tuple[int, int]]) -> int:
+        """Count number of k-stars in the edge set."""
+        if not edge_set:
+            return 0
+            
+        # Build graph from edge set
+        G = nx.Graph()
+        G.add_edges_from(edge_set)
+        
+        k_star_count = 0
+        
+        if self.k == 3:
+          all_claws = claws.find_claw_coordinates(G, first_claw=False)
+          if all_claws is not None:
+            k_star_count = len(all_claws)
+        else:
+            # Check each vertex as potential center of k-star
+            for center in G.nodes():
+                neighbors = list(G.neighbors(center))
+                if len(neighbors) >= self.k:
+                    # Count k-subsets of neighbors that form independent sets
+                    for k_subset in itertools.combinations(neighbors, self.k):
+                        # Check if this k-subset is independent
+                        is_independent = True
+                        for i in range(self.k):
+                            for j in range(i + 1, self.k):
+                                if G.has_edge(k_subset[i], k_subset[j]):
+                                    is_independent = False
+                                    break
+                            if not is_independent:
+                                break
+                        
+                        if is_independent:
+                            k_star_count += 1
+            
+        return k_star_count
+    
+    def _repair_violations(self, edge_set: Set[Tuple[int, int]]) -> Set[Tuple[int, int]]:
+        """
+        Repair k-star violations in edge_set by removing minimal edges.
+        This is the key part of the BEL algorithm.
+        """
+        if not edge_set:
+            return edge_set
+            
+        current_set = edge_set.copy()
+        
+        while True:
+            if self.k == 3:
+                is_claw_free = self._is_claw_free(current_set)
+                if is_claw_free:
+                    break  # No more violations
+                violations = self._find_k_stars(current_set)
+            else:        
+                violations = self._find_k_stars(current_set)
+                if not violations:
+                    break  # No more violations
+                
+            # Find the edge that appears in most violations
+            edge_violation_count = defaultdict(int)
+            for k_star in violations:
+                center, leaves = k_star
+                # Each k-star consists of k edges from center to leaves
+                for leaf in leaves:
+                    edge = (min(center, leaf), max(center, leaf))
+                    if edge in current_set:
+                        edge_violation_count[edge] += 1
+            
+            if not edge_violation_count:
+                break
+                
+            # Remove the edge that appears in most violations
+            most_violating_edge = max(edge_violation_count.keys(), 
+                                    key=lambda e: edge_violation_count[e])
+            current_set.remove(most_violating_edge)
+        
+        return current_set
+    
+    def _find_k_stars(self, edge_set: Set[Tuple[int, int]]) -> List[Tuple[int, Tuple]]:
+        """Find all k-stars in the edge set. Returns list of (center, leaves) tuples."""
+        if not edge_set:
+            return []
+            
+        # Build graph from edge set
+        G = nx.Graph()
+        G.add_edges_from(edge_set)
+        
+        k_stars = []
+        
+        if self.k == 3:
+          all_claws = claws.find_claw_coordinates(G, first_claw=False)
+          if all_claws is not None:
+            for subset in all_claws:
+                subgraph = G.subgraph(subset)
+                sorted_nodes = sorted(list(subset), key=lambda x: subgraph.degree(x))
+                center = sorted_nodes.pop()
+                k_subset = tuple(sorted_nodes)
+                k_stars.append((center, k_subset))
+        else:
+          # Check each vertex as potential center of k-star
+          for center in G.nodes():
+              neighbors = list(G.neighbors(center))
+              if len(neighbors) >= self.k:
+                  # Find all k-subsets of neighbors that form independent sets
+                  for k_subset in itertools.combinations(neighbors, self.k):
+                      # Check if this k-subset is independent
+                      is_independent = True
+                      for i in range(self.k):
+                          for j in range(i + 1, self.k):
+                              if G.has_edge(k_subset[i], k_subset[j]):
+                                  is_independent = False
+                                  break
+                          if not is_independent:
+                              break
+                      
+                      if is_independent:
+                          k_stars.append((center, k_subset))
+          
+        return k_stars
+    
+    def verify_partition(self, E1: Set[Tuple[int, int]], E2: Set[Tuple[int, int]]) -> Tuple[bool, bool]:
+        """Verify that both partitions are k-star-free."""
+        if self.k == 3:
+            return (self._is_claw_free(E1), self._is_claw_free(E2))
+        else:    
+            return (self._count_k_stars(E1) == 0, self._count_k_stars(E2) == 0)
+
+
+def partition_edges_claw_free(G: nx.Graph) -> Tuple[Set[Tuple[int, int]], Set[Tuple[int, int]]]:
+    """
+    Partition edges of graph G into two sets such that each induces a claw-free subgraph.
+    
+    Implementation of Burr, Erdős, Lovász (1976) algorithm for k=3 (claw-free case).
+    
+    Args:
+        G: Undirected NetworkX graph
+        
+    Returns:
+        (E1, E2): Two edge sets that induce claw-free subgraphs
+    """
+    partitioner = BurrErdosLovaszPartitioner(G, k=3)
+    return partitioner.partition_edges()
+

alonso/stable.py

@@ -0,0 +1,186 @@
+from collections import defaultdict
+import networkx as nx
+
+class FaenzaOrioloStaufferAlgorithm:
+    """
+    Implementation of the Faenza, Oriolo & Stauffer (2011) algorithm
+    for finding maximum weighted stable set in claw-free graphs.
+    """
+    
+    def __init__(self, edges, weights=None):
+        """
+        Initialize the algorithm with graph edges and optional vertex weights.
+        
+        Args:
+            edges: List of tuples representing edges
+            weights: Dictionary mapping vertices to weights (default: all weights = 1)
+        """
+        self.edges = [(u, v) for u, v in edges]
+        self.vertices = set()
+        for u, v in self.edges:
+            self.vertices.add(u)
+            self.vertices.add(v)
+        self.graph = nx.Graph()
+        self.graph.add_edges_from(self.edges)
+        self.n = len(self.vertices)
+        if weights is None:
+            self.weights = {v: 1 for v in self.vertices}
+        else:
+            self.weights = {k: v for k, v in weights.items()}
+        
+        # Build adjacency list
+        self.adj = defaultdict(set)
+        for u, v in self.edges:
+            self.adj[u].add(v)
+            self.adj[v].add(u)
+    
+    def find_stable_set_decomposition(self):
+        """
+        Find a stable set decomposition of the graph.
+        This is a key step in the FOS algorithm.
+        """
+        # For simplicity, we'll use a greedy approach to find stable sets
+        # In the full algorithm, this would use more sophisticated decomposition
+        remaining_vertices = set(self.vertices)
+        stable_sets = []
+        
+        while remaining_vertices:
+            # Greedy maximal stable set
+            current_stable = set()
+            vertices_to_check = list(remaining_vertices)
+            
+            for v in vertices_to_check:
+                if v in remaining_vertices:
+                    # Check if v can be added to current stable set
+                    can_add = True
+                    for u in current_stable:
+                        if u in self.adj[v]:
+                            can_add = False
+                            break
+                    
+                    if can_add:
+                        current_stable.add(v)
+                        remaining_vertices.remove(v)
+            
+            if current_stable:
+                stable_sets.append(current_stable)
+        
+        return stable_sets
+    
+    def solve_weighted_stable_set_on_clique(self, clique_vertices):
+        """
+        Solve maximum weighted stable set on a clique (trivial: pick heaviest vertex).
+        """
+        if not clique_vertices:
+            return set(), 0
+        
+        best_vertex = max(clique_vertices, key=lambda v: self.weights[v])
+        return {best_vertex}, self.weights[best_vertex]
+    
+    def is_clique(self, vertices):
+        """Check if given vertices form a clique."""
+        G = self.graph.subgraph(vertices)
+        n = G.number_of_nodes()
+        if n < 2:
+            return True
+        e = G.number_of_edges()
+        max_edges = (n * (n - 1)) / 2
+        return e == max_edges
+
+    def find_maximum_weighted_stable_set(self):
+        """
+        Main algorithm to find maximum weighted stable set.
+        This implements the core FOS algorithm structure.
+        """
+        # Base cases
+        if not self.vertices:
+            return set(), 0
+        
+        if len(self.vertices) == 1:
+            v = next(iter(self.vertices))
+            return {v}, self.weights[v]
+        
+        # Check if graph is a clique
+        if self.is_clique(self.vertices):
+            return self.solve_weighted_stable_set_on_clique(self.vertices)
+        
+        # For claw-free graphs, we use dynamic programming approach
+        # This is a simplified version of the full FOS algorithm
+        return self._dp_solve()
+    
+    def _dp_solve(self):
+        """
+        Dynamic programming solution for claw-free graphs.
+        This implements the polynomial-time algorithm structure from FOS.
+        """
+        # Convert to networkx for easier manipulation
+        G = nx.Graph()
+        G.add_nodes_from(self.vertices)
+        G.add_edges_from(self.edges)
+        
+        # Use complement graph approach for stable set = clique in complement
+        G_complement = nx.complement(G)
+        
+        # Find all maximal cliques in complement (these are maximal stable sets in original)
+        maximal_stable_sets = list(nx.find_cliques(G_complement))
+        
+        # Find the one with maximum weight
+        best_stable_set = set()
+        best_weight = 0
+        
+        for stable_set in maximal_stable_sets:
+            weight = sum(self.weights[v] for v in stable_set)
+            if weight > best_weight:
+                best_weight = weight
+                best_stable_set = set(stable_set)
+        
+        # Also check individual vertices
+        for v in self.vertices:
+            if self.weights[v] > best_weight:
+                best_weight = self.weights[v]
+                best_stable_set = {v}
+        
+        return best_stable_set, best_weight
+    
+    def verify_stable_set(self, stable_set):
+        """Verify that the given set is indeed a stable set."""
+        stable_list = list(stable_set)
+        for i in range(len(stable_list)):
+            for j in range(i + 1, len(stable_list)):
+                if stable_list[j] in self.adj[stable_list[i]]:
+                    return False, f"Vertices {stable_list[i]} and {stable_list[j]} are adjacent"
+        return True, "Valid stable set"
+
+
+def solve_maximum_weighted_stable_set(edges, weights=None):
+    """
+    Solve maximum weighted stable set problem using FOS algorithm.
+    
+    Args:
+        edges: List of edges as tuples
+        weights: Dictionary of vertex weights (optional, defaults to 1 for all)
+    
+    Returns:
+        tuple: (stable_set, weight)
+    """
+    algorithm = FaenzaOrioloStaufferAlgorithm(edges, weights)
+    return algorithm.find_maximum_weighted_stable_set()
+
+def minimum_vertex_cover_claw_free(edges, weights=None):
+    """
+    Solve minimum vertex cover problem using FOS algorithm.
+    
+    Args:
+        edges: List of edges as tuples
+        weights: Dictionary of vertex weights (optional, defaults to 1 for all)
+            
+    Returns:
+        - A minimum vertex cover
+    """
+    algorithm = FaenzaOrioloStaufferAlgorithm(edges, weights)
+    stable_set, _ = algorithm.find_maximum_weighted_stable_set()
+    G = nx.Graph()
+    G.add_edges_from(edges)
+    minimum_vertex_cover = set(G.nodes) - stable_set
+    return minimum_vertex_cover
+

alonso/test.py

@@ -0,0 +1,118 @@
+# Created on 21/05/2025
+# Author: Frank Vega
+
+import time
+import argparse
+import math
+import networkx as nx
+
+from . import algorithm
+from . import applogger
+from . import parser
+from . import utils
+
+def restricted_float(x):
+    try:
+        x = float(x)
+    except ValueError:
+        raise argparse.ArgumentTypeError("%r not a floating-point literal" % (x,))
+
+    if x < 0.0 or x > 1.0:
+        raise argparse.ArgumentTypeError("%r not in range [0.0, 1.0]"%(x,))
+    return x
+
+def main():
+    
+    # Define the parameters
+    helper = argparse.ArgumentParser(prog="test_mvc", description="The Alonso Testing Application using randomly generated, large sparse matrices.")
+    helper.add_argument('-d', '--dimension', type=int, help="an integer specifying the dimensions of the square matrices", required=True)
+    helper.add_argument('-n', '--num_tests', type=int, default=5, help="an integer specifying the number of tests to run")
+    helper.add_argument('-s', '--sparsity', type=restricted_float, default=0.95, help="sparsity of the matrices (0.0 for dense, close to 1.0 for very sparse)")
+    helper.add_argument('-a', '--approximation', action='store_true', help='enable comparison with a polynomial-time approximation approach within a factor of at most 2')
+    helper.add_argument('-b', '--bruteForce', action='store_true', help='enable comparison with the exponential-time brute-force approach')
+    helper.add_argument('-c', '--count', action='store_true', help='calculate the size of the vertex cover')
+    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.1')
+    
+    # Initialize the parameters
+    args = helper.parse_args()
+    num_tests = args.num_tests
+    matrix_shape = (args.dimension, args.dimension)
+    sparsity = args.sparsity
+    logger = applogger.Logger(applogger.FileLogger() if (args.log) else applogger.ConsoleLogger(args.verbose))
+    hash_string = utils.generate_short_hash(6 + math.ceil(math.log2(num_tests))) if args.write else None
+    count = args.count
+    bruteForce = args.bruteForce
+    approximation = args.approximation
+    # Perform the tests    
+    for i in range(num_tests):
+        
+        logger.info(f"Creating Matrix {i + 1}")
+        
+        sparse_matrix = utils.random_matrix_tests(matrix_shape, sparsity)
+
+        if sparse_matrix is None:
+            continue
+
+        graph = utils.sparse_matrix_to_graph(sparse_matrix)    
+        logger.info(f"Matrix shape: {sparse_matrix.shape}")
+        logger.info(f"Number of non-zero elements: {sparse_matrix.nnz}")
+        logger.info(f"Sparsity: {1 - (sparse_matrix.nnz / (sparse_matrix.shape[0] * sparse_matrix.shape[1]))}")
+        
+        if approximation:
+            logger.info("An approximate Solution with an approximation ratio of at most 2 started")
+            started = time.time()
+            
+            approximate_result = algorithm.find_vertex_cover_approximation(graph)
+
+            logger.info(f"An approximate Solution with an approximation ratio of at most 2 done in: {(time.time() - started) * 1000.0} milliseconds")
+            
+            answer = utils.string_result_format(approximate_result, count)
+            output = f"{i + 1}-approximation Test: {answer}" 
+            utils.println(output, logger, args.log)    
+    
+        if bruteForce:
+            logger.info("A solution with an exponential-time complexity started")
+            started = time.time()
+            
+            brute_force_result = algorithm.find_vertex_cover_brute_force(graph)
+
+            logger.info(f"A solution with an exponential-time complexity done in: {(time.time() - started) * 1000.0} milliseconds")
+            
+            answer = utils.string_result_format(brute_force_result, count)
+            output = f"{i + 1}-Brute Force Test: {answer}" 
+            utils.println(output, logger, args.log)
+        
+
+        logger.info("Our Algorithm with an approximate solution started")
+        started = time.time()
+        
+        novel_result = algorithm.find_vertex_cover(graph)
+
+        logger.info(f"Our Algorithm with an approximate solution done in: {(time.time() - started) * 1000.0} milliseconds")
+
+        answer = utils.string_result_format(novel_result, count)
+        output = f"{i + 1}-Alonso Test: {answer}" 
+        utils.println(output, logger, args.log)
+
+        if novel_result and (bruteForce or approximation):
+            if bruteForce:    
+                output = f"Exact Ratio (Alonso/Optimal): {len(novel_result)/len(brute_force_result)}"
+            elif approximation:
+                output = f"Upper Bound for Ratio (Alonso/Optimal): {2 * len(novel_result)/len(approximate_result)}"
+            utils.println(output, logger, args.log)
+        
+
+        if args.write:
+            output = f"Saving Matrix Test {i + 1}" 
+            utils.println(output, logger, args.log)
+    
+            filename = f"sparse_matrix_{i + 1}_{hash_string}"
+            parser.save_sparse_matrix_to_file(sparse_matrix, filename)
+            output = f"Matrix Test {i + 1} written to file {filename}." 
+            utils.println(output, logger, args.log)
+    
+if __name__ == "__main__":
+  main()