alonso 0.0.1__py3-none-any.whl

alonso/__init__.py

@@ -0,0 +1,4 @@
+# Alonso: Approximate Vertex Cover Solver https://pypi.org/project/alonso
+# Author: Frank Vega
+
+__all__ = ["utils", "bipartite", "algorithm", "parser", "applogger", "test", "app", "batch"]

alonso/algorithm.py

@@ -0,0 +1,115 @@
+# Created on 21/05/2025
+# Author: Frank Vega
+
+import itertools
+from . import utils
+
+import networkx as nx
+from . import partition
+from . import stable
+from . import merge
+
+def find_vertex_cover(graph):
+    """
+    Compute an approximate minimum vertex cover set for an undirected graph by transforming it into a chordal graph.
+
+    Args:
+        graph (nx.Graph): A NetworkX Graph object representing the input graph.
+
+    Returns:
+        set: A set of vertex indices representing the approximate minimum vertex cover set.
+             Returns an empty set if the graph is empty or has no edges.
+    """
+    # 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()
+    
+    # Partition edges into two subsets (E1, E2) using the Burr-Erdős-Lovász (1976) algorithm
+    # This step divides the graph into two claw-free subgraphs
+    # Complexity: O(m * (m * Δ * C + C^2)), where m is edges, Δ is maximum degree, C is number of claws
+    E1, E2 = partition.partition_edges_claw_free(working_graph)
+    
+    # Compute minimum vertex cover for E1 using the Faenza, Oriolo & Stauffer (2011) algorithm
+    # This finds the maximum weighted stable set in the claw-free graph E1, whose complement is the vertex cover
+    # Complexity: O(n^3), where n is the number of nodes in the subgraph induced by E1
+    vertex_cover_1 = stable.minimum_vertex_cover_claw_free(E1)
+    
+    # Compute minimum vertex cover for E2 using the same Faenza, Oriolo & Stauffer (2011) algorithm
+    # Complexity: O(n^3) for the subgraph induced by E2
+    vertex_cover_2 = stable.minimum_vertex_cover_claw_free(E2)
+
+    # Merge the two vertex covers from E1 and E2 to approximate the minimum vertex cover of the original graph
+    approximate_vertex_cover = merge.merge_vertex_covers(E1, E2, vertex_cover_1, vertex_cover_2)
+    
+    # Create a residual graph containing edges not covered by the current vertex cover
+    residual_graph = nx.Graph()
+    for u, v in working_graph.edges():
+        if u not in approximate_vertex_cover and v not in approximate_vertex_cover:
+            residual_graph.add_edge(u, v)  # Add edge if neither endpoint is in the cover
+    
+    # Recursively find vertex cover for the residual graph to handle uncovered edges
+    residual_vertex_cover = find_vertex_cover(residual_graph)
+    
+    # Combine the approximate vertex cover with the residual cover to ensure all edges are covered
+    return approximate_vertex_cover.union(residual_vertex_cover)
+
+def find_vertex_cover_brute_force(graph):
+    """
+    Computes an exact minimum vertex cover in exponential time.
+
+    Args:
+        graph: A NetworkX Graph.
+
+    Returns:
+        A set of vertex indices representing the exact vertex cover, or None if the graph is empty.
+    """
+
+    if graph.number_of_nodes() == 0 or graph.number_of_edges() == 0:
+        return None
+
+    n_vertices = len(graph.nodes())
+
+    for k in range(1, n_vertices + 1): # Iterate through all possible sizes of the cover
+        for candidate in itertools.combinations(graph.nodes(), k):
+            cover_candidate = set(candidate)
+            if utils.is_vertex_cover(graph, cover_candidate):
+                return cover_candidate
+                
+    return None
+
+
+
+def find_vertex_cover_approximation(graph):
+    """
+    Computes an approximate vertex cover in polynomial time with an approximation ratio of at most 2 for undirected graphs.
+
+    Args:
+        graph: A NetworkX Graph.
+
+    Returns:
+        A set of vertex indices representing the approximate vertex cover, or None if the graph is empty.
+    """
+
+    if graph.number_of_nodes() == 0 or graph.number_of_edges() == 0:
+        return None
+
+    #networkx doesn't have a guaranteed minimum vertex cover function, so we use approximation
+    vertex_cover = nx.approximation.vertex_cover.min_weighted_vertex_cover(graph)
+    return vertex_cover

alonso/app.py

@@ -0,0 +1,98 @@
+#                   Approximate Vertex Cover Solver
+#                          Frank Vega
+#                       May 21th, 2025
+
+import argparse
+import time
+
+from . import algorithm
+from . import parser
+from . import applogger
+from . import utils
+
+def approximate_solution(inputFile, verbose=False, log=False, count=False, bruteForce=False, approximation=False):
+    """Finds an approximate vertex cover.
+
+    Args:
+        inputFile: Input file path.
+        verbose: Enable verbose output.
+        log: Enable file logging.
+        count: Measure the size of the vertex cover.
+        bruteForce: Enable brute force approach.
+        approximation: Enable an approximate approach within a ratio of at most 2.
+    """
+    
+    logger = applogger.Logger(applogger.FileLogger() if (log) else applogger.ConsoleLogger(verbose))
+    # Read and parse a dimacs file
+    logger.info(f"Parsing the Input File started")
+    started = time.time()
+    
+    graph = parser.read(inputFile)
+    filename = utils.get_file_name(inputFile)
+    logger.info(f"Parsing the Input File done in: {(time.time() - started) * 1000.0} milliseconds")
+    
+    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"{filename}: (approximation) {answer}"
+        utils.println(output, logger, 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"{filename}: (Brute Force) {answer}"
+        utils.println(output, logger, 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"{filename}: {answer}"
+    utils.println(output, logger, 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, log)
+          
+def main():
+    
+    # Define the parameters
+    helper = argparse.ArgumentParser(prog="mvc", description='Compute an Approximate Vertex Cover for undirected graph encoded in DIMACS format.')
+    helper.add_argument('-i', '--inputFile', type=str, help='input file path', required=True)
+    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('-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()
+    approximate_solution(args.inputFile, 
+               verbose=args.verbose, 
+               log=args.log,
+               count=args.count,
+               bruteForce=args.bruteForce,
+               approximation=args.approximation)
+  
+
+if __name__ == "__main__":
+    main()

alonso/applogger.py

@@ -0,0 +1,80 @@
+import logging
+
+class Logger:
+    """
+    A wrapper class for a logger object.
+    """
+
+    def __init__(self, logger):
+        """
+        Initializes the SatLogger with a logger object.
+
+        Args:
+            logger (logging.Logger): The underlying logger object to be used.
+        """
+        self.logger = logger
+
+    def info(self, msg, *args, **kwargs):
+        """
+        Logs an informational message using the underlying logger.
+
+        Args:
+            msg (str): The message to be logged.
+            *args: Additional arguments to be passed to the underlying logger's info method.
+            **kwargs: Additional keyword arguments to be passed to the underlying logger's info method.
+        """
+        self.logger.info(msg, *args, **kwargs)
+
+class ConsoleLogger:
+    """
+    A simple logger class that logs to the console when enabled.
+    """
+
+    def __init__(self, log_enabled=True):
+        """
+        Initializes the ConsoleLogger with an optional flag for enabling logging.
+
+        Args:
+            log_enabled (bool, optional): Flag to enable or disable console logging. Defaults to True.
+        """
+        self.log_enabled = log_enabled
+
+    def info(self, msg, *args, **kwargs):
+        """
+        Logs a message to the console if enabled.
+
+        Args:
+            msg (str): The message to be logged.
+            *args: Additional arguments to be formatted with the message.
+            **kwargs: Additional keyword arguments (ignored for console logging).
+        """
+
+        if self.log_enabled:
+            print(msg.format(*args))  # Use f-strings or format method for cleaner formatting
+
+class FileLogger:
+    """
+    A simple logger class that logs to a file.
+    """
+
+    def __init__(self, log_file="app.log", log_level=logging.INFO):
+        """
+        Initializes the FileLogger with an optional log file name and log level.
+
+        Args:
+            log_file (str, optional): The filename of the log file. Defaults to "app.log".
+            log_level (int, optional): The logging level. Defaults to logging.INFO.
+        """
+        logging.basicConfig(filename=log_file, level=log_level, format='%(asctime)s - %(levelname)s - %(message)s')
+        self.logger = logging.getLogger(__name__)
+
+    def info(self, msg, *args, **kwargs):
+        """
+        Logs an informational message to the file.
+
+        Args:
+            msg (str): The message to be logged.
+            *args: Additional arguments to be formatted with the message.
+            **kwargs: Additional keyword arguments (ignored for file logging).
+        """
+        self.logger.info(msg.format(*args))

alonso/batch.py

@@ -0,0 +1,53 @@
+# Created on 21/05/2025
+# Author: Frank Vega
+
+import argparse
+from . import utils
+from . import app
+
+def approximate_solutions(inputDirectory, verbose=False, log=False, count=False, bruteForce=False, approximation=False):
+    """Finds an approximate vertex cover for several instances.
+
+    Args:
+        inputDirectory: Input directory path.
+        verbose: Enable verbose output.
+        log: Enable file logging.
+        count: Measure the size of the vertex cover.
+        bruteForce: Enable brute force approach.
+        approximation: Enable an approximate approach within a ratio of at most 2.
+    """
+    
+    file_names = utils.get_file_names(inputDirectory)
+
+    if file_names:
+        for file_name in file_names:
+            inputFile = f"{inputDirectory}/{file_name}"
+            print(f"Test: {inputDirectory}/{file_name}")
+            app.approximate_solution(inputFile, verbose, log, count, bruteForce, approximation)
+
+
+def main():
+    
+    # Define the parameters
+    helper = argparse.ArgumentParser(prog="batch_mvc", description="Compute an Approximate Vertex Cover for all undirected graphs encoded in DIMACS format and stored in a directory.")
+    helper.add_argument('-i', '--inputDirectory', type=str, help='Input directory path', required=True)
+    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('-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()
+    approximate_solutions(args.inputDirectory, 
+               verbose=args.verbose, 
+               log=args.log,
+               count=args.count,
+               bruteForce=args.bruteForce,
+               approximation=args.approximation)
+
+
+if __name__ == "__main__":
+  main()      

alonso/merge.py

@@ -0,0 +1,125 @@
+def merge_vertex_covers(E1, E2, vertex_cover_1, vertex_cover_2):
+    """
+    Merge two vertex covers from edge partitions to get minimum vertex cover of G.
+    
+    Args:
+        G: Graph represented as adjacency list/set of edges
+        E1, E2: Two partitions of edges E
+        vertex_cover_1: Vertex cover for subgraph induced by E1
+        vertex_cover_2: Vertex cover for subgraph induced by E2
+    
+    Returns:
+        Merged vertex cover for the entire graph G
+    """
+    # All edges in the graph
+    all_edges = E1.union(E2)
+    
+    # Initialize merge process
+    merged_cover = set()
+    covered_edges = set()
+    
+    # Convert vertex covers to lists for merge-sort-like processing
+    candidates_1 = list(vertex_cover_1)
+    candidates_2 = list(vertex_cover_2)
+    
+    i, j = 0, 0
+    
+    # Merge process similar to merge sort
+    while i < len(candidates_1) or j < len(candidates_2):
+        # Calculate uncovered edges that each candidate can cover
+        uncovered_edges = all_edges - covered_edges
+        
+        if not uncovered_edges:
+            break
+            
+        # Get coverage count for remaining candidates
+        coverage_1 = 0
+        coverage_2 = 0
+        
+        if i < len(candidates_1):
+            v1 = candidates_1[i]
+            coverage_1 = count_edges_covered_by_vertex(v1, uncovered_edges)
+        
+        if j < len(candidates_2):
+            v2 = candidates_2[j]
+            coverage_2 = count_edges_covered_by_vertex(v2, uncovered_edges)
+        
+        # Choose vertex that covers more uncovered edges (merge-sort comparison)
+        if i >= len(candidates_1):
+            # Only candidates from cover_2 remain
+            chosen_vertex = candidates_2[j]
+            j += 1
+        elif j >= len(candidates_2):
+            # Only candidates from cover_1 remain
+            chosen_vertex = candidates_1[i]
+            i += 1
+        elif coverage_1 >= coverage_2:
+            # Vertex from cover_1 covers more (or equal) uncovered edges
+            chosen_vertex = candidates_1[i]
+            i += 1
+            # Skip if same vertex exists in both covers
+            if j < len(candidates_2) and candidates_2[j] == chosen_vertex:
+                j += 1
+        else:
+            # Vertex from cover_2 covers more uncovered edges
+            chosen_vertex = candidates_2[j]
+            j += 1
+            # Skip if same vertex exists in both covers
+            if i < len(candidates_1) and candidates_1[i] == chosen_vertex:
+                i += 1
+        
+        # Add chosen vertex to merged cover
+        if chosen_vertex not in merged_cover:
+            merged_cover.add(chosen_vertex)
+            # Update covered edges
+            newly_covered = get_edges_covered_by_vertex(chosen_vertex, uncovered_edges)
+            covered_edges.update(newly_covered)
+    
+    return merged_cover
+
+
+def count_edges_covered_by_vertex(vertex, edges):
+    """Count how many edges from the given set are covered by the vertex."""
+    count = 0
+    for edge in edges:
+        if vertex in edge:
+            count += 1
+    return count
+
+
+def get_edges_covered_by_vertex(vertex, edges):
+    """Get all edges from the given set that are covered by the vertex."""
+    covered = set()
+    for edge in edges:
+        if vertex in edge:
+            covered.add(edge)
+    return covered
+
+
+def find_vertex_cover_subgraph(edges):
+    """
+    Find a vertex cover for the subgraph induced by given edges.
+    This is a simplified greedy approach for demonstration.
+    """
+    cover = set()
+    uncovered_edges = set(edges)
+    
+    while uncovered_edges:
+        # Find vertex that covers most uncovered edges
+        vertex_count = {}
+        for edge in uncovered_edges:
+            for vertex in edge:
+                vertex_count[vertex] = vertex_count.get(vertex, 0) + 1
+        
+        # Choose vertex with maximum coverage
+        best_vertex = max(vertex_count.keys(), key=lambda v: vertex_count[v])
+        cover.add(best_vertex)
+        
+        # Remove covered edges
+        to_remove = set()
+        for edge in uncovered_edges:
+            if best_vertex in edge:
+                to_remove.add(edge)
+        uncovered_edges -= to_remove
+    
+    return cover

alonso/parser.py

@@ -0,0 +1,79 @@
+import lzma
+import bz2
+import numpy as np
+import scipy.sparse as sparse
+import networkx as nx
+
+from . import utils
+
+def create_sparse_matrix_from_file(file):
+    """Creates a sparse matrix from a file containing a DIMACS format representation.
+
+    Args:
+        file: A file-like object (e.g., an opened file) containing the matrix data.
+
+    Returns:
+        A NetworkX Graph.
+
+    Raises:
+        ValueError: If the input matrix is not the correct DIMACS format.
+    """
+    graph = nx.Graph()
+    for i, line in enumerate(file):
+        line = line.strip()  # Remove newline characters
+        if not line.startswith('c') and not line.startswith('p'):
+            edge = [np.int32(node) for node in line.split(' ') if node != 'e']
+            if len(edge) != 2 or min(edge[0], edge[1]) <= 0:
+                raise ValueError(f"The input file is not in the correct DIMACS format at line {i}")
+            elif graph.has_edge(edge[0] - 1, edge[1] - 1):
+                raise ValueError(f"The input file contains a repeated edge at line {i}")
+            else:
+                graph.add_edge(edge[0] - 1, edge[1] - 1)
+    
+    return graph
+
+def save_sparse_matrix_to_file(matrix, filename):
+    """
+    Writes a SciPy sparse matrix to a DIMACS format.
+
+    Args:
+        matrix: The SciPy sparse matrix.
+        filename: The name of the output text file.
+    """
+    rows, cols = matrix.nonzero()
+    
+    with open(filename, 'w') as f:
+        f.write(f"p edge {matrix.shape[0]} {matrix.nnz // 2 - matrix.shape[0]//2}" + "\n")
+        for i, j in zip(rows, cols):
+            if i < j:
+                f.write(f"e {i + 1} {j + 1}" + "\n")
+    
+
+def read(filepath):
+    """Reads a file and returns its lines in an array format.
+
+    Args:
+        filepath: The path to the file.
+
+    Returns:
+        A NetworkX Graph.
+
+    Raises:
+        FileNotFoundError: If the file is not found.
+    """
+
+    try:
+        extension = utils.get_extension_without_dot(filepath)
+        if extension == 'xz' or extension == 'lzma':
+            with lzma.open(filepath, 'rt') as file:
+                matrix = create_sparse_matrix_from_file(file)
+        elif extension == 'bz2' or extension == 'bzip2':
+            with bz2.open(filepath, 'rt') as file:
+                matrix = create_sparse_matrix_from_file(file)
+        else:
+            with open(filepath, 'r') as file:
+                matrix = create_sparse_matrix_from_file(file)
+        
+        return matrix
+    except FileNotFoundError:
+        raise FileNotFoundError(f"File not found: {filepath}")