A √n-Approximation for Independent Sets: The Furones Algorithm

1. Introduction

The Maximum Independent Set (MIS) problem is a cornerstone of graph theory and combinatorial optimization [1]. Given an undirected graph $G=(V,E)$, where V is the set of vertices and E is the edges, an independent set is a subset $S\subseteq V$ such that no two vertices in S are adjacent, i.e., for all $u,v\in S$, $(u,v)\notin E$. The goal of the MIS problem is to find an independent set S with the maximum cardinality, denoted $\mathrm{OPT}={max}_{S\mathrm{independent}}\left|S\right|$. The size of the maximum independent set is also called the independence number of the graph, denoted $\alpha \left(G\right)$.

The MIS problem arises in numerous applications, including scheduling, where tasks must be assigned without conflicts; network design, for selecting non-interfering nodes; and coding theory, for constructing error-correcting codes. However, the problem is computationally challenging, as it is NP-hard for general graphs, meaning no polynomial-time algorithm is known to solve it exactly unless $\mathrm{P}=\mathrm{NP}$. This hardness motivates the development of approximation algorithms that produce near-optimal solutions efficiently.

The NP-hardness of MIS has led to extensive research on approximation algorithms, particularly for general graphs where exact solutions are infeasible for large instances. The quality of an approximation algorithm is measured by its approximation ratio, defined as ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}$, where $\left|S\right|$ is the size of the independent set produced by the algorithm. A smaller ratio indicates a better approximation. Below, we summarize key results in the state of the art for MIS approximation algorithms:

• Greedy Algorithms: A simple greedy algorithm selects vertices in order of increasing degree, adding a vertex to the independent set if it has no neighbors in the current set. This achieves an approximation ratio of $O(\Delta )$, where $\Delta$ is the maximum degree. For graphs with high degrees ($\Delta \approx n-1$), this yields a poor ratio of $O\left(n\right)$. A more sophisticated greedy approach, selecting vertices by minimum degree iteratively, achieves an approximation ratio of $O(n/logn)$, as shown by Halldórsson and Radhakrishnan [2].
• Local Search and Randomized Algorithms: Local search techniques, such as those by Boppana and Halldórsson [3], improve the approximation ratio to $O(n/{(logn)}^2)$ by iteratively swapping small subsets of vertices to increase the independent set size. Randomized algorithms, like those based on random vertex selection or Lovász Local Lemma, can achieve similar ratios with probabilistic guarantees.
• Semidefinite Programming (SDP): Advanced techniques using SDP, such as those by Karger, Motwani, and Sudan [4], achieve approximation ratios of $O(n/logn)$ for general graphs. For specific graph classes, such as 3-colorable graphs, better ratios (e.g., $O\left(\sqrt{n}\right)$) are possible.
• Hardness of Approximation: The MIS problem is notoriously difficult to approximate. Håstad [5] and others have shown that, assuming $\mathrm{P}\ne \mathrm{NP}$, no polynomial-time algorithm can achieve an approximation ratio better than $O\left(n^{1-ϵ}\right)$ for any $ϵ>0$. This inapproximability result underscores the challenge of finding near-optimal solutions.
• Special Graph Classes: For specific graph classes, better approximations exist. For bipartite graphs, the maximum independent set can be computed exactly in polynomial time using maximum matching algorithms (via König’s theorem). For graphs with bounded degree or specific structures (e.g., planar graphs), constant-factor approximations are achievable.

The state of the art highlights a trade-off between computational efficiency and approximation quality. Simple greedy algorithms are fast but yield poor ratios, while SDP-based methods offer better ratios at the cost of higher computational complexity. The challenge remains to design algorithms that balance runtime and approximation ratio, especially for general graphs.

Our hybrid algorithm computes an approximate maximum independent set for an undirected graph $G=(V,E)$ with n vertices and m edges. It begins by preprocessing the graph to remove self-loops and isolated nodes, handling trivial cases (empty or edgeless graphs) by returning the empty set or all vertices, respectively. If the graph is bipartite, it computes the maximum independent set exactly using the Hopcroft-Karp matching algorithm and König’s theorem, taking $O(n+m+\sqrt{n}m)$ time. For non-bipartite graphs, it employs four strategies:

• Iterative Refinement: Initializes a candidate set with all non-isolated vertices and iteratively refines it by constructing a maximum spanning tree of the induced subgraph, computing its maximum independent set (since trees are bipartite) using a matching-based approach, and updating the candidate set until it is independent in G. A greedy extension adds vertices to ensure maximality, producing $S_{\mathrm{iterative}}$.
• Greedy Minimum-Degree Selection: Sorts vertices by increasing degree and builds an independent set by adding each vertex if it has no neighbors in the current set, producing $S_{\min -\mathrm{greedy}}$.
• Greedy Maximum-Degree Selection: Sorts vertices by decreasing degree and builds an independent set by adding each vertex if it has no neighbors in the current set, producing $S_{\max -\mathrm{greedy}}$.
• Low-Degree Induced Subgraph: Computes an independent set on the induced subgraph of vertices with degree strictly less than the maximum degree, using the minimum-degree greedy heuristic, producing $S_{\mathrm{low}}$.

The algorithm selects the largest of $S_{\mathrm{iterative}}$, $S_{\min -\mathrm{greedy}}$, $S_{\max -\mathrm{greedy}}$, and $S_{\mathrm{low}}$, then adds isolated nodes to form the final set S. The is_independent_set subroutine, running in $O\left(m\right)$ time, verifies independence by checking all edges. The hybrid approach guarantees a valid, maximal independent set with a worst-case approximation ratio of $\sqrt{n}$, robustly handling diverse graph structures, including graphs with multiple cliques sharing a universal vertex. Its time complexity is $O(nmlogn)$, dominated by the iterative refinement, making it suitable for small-to-medium graphs. While less competitive than $O(n/logn)$-ratio algorithms for large instances, its simplicity, use of standard graph operations (via NetworkX), and robustness make it an effective educational tool for studying approximation algorithms and combinatorial optimization.

2. Research Data

A Python implementation, titled Furones: Approximate Independent Set Solver has been developed to efficiently solve the Approximate Independent Set Problem. The solver is publicly available via the Python Package Index (PyPI) [6] and guarantees a rigorous approximation ratio of at most $\sqrt{n}$ for the Independent Set Problem. Code metadata and ancillary details are provided in Table 1.

3. Correctness of the Maximum Independent Set Algorithm

The algorithm under consideration computes an approximate independent set using maximum spanning trees and combining with greedy approaches to ensure maximality. We prove that the algorithm’s output is always a valid independent set.

3.1. Algorithm Description

Figure A1 presents the core implementation. The hybrid algorithm combines iterative refinement using maximum spanning trees with greedy minimum-degree, maximum-degree selections, and a low-degree induced subgraph heuristic, returning the largest independent set, followed by a greedy extension on the tree-based candidate to further maximize it, to achieve a $\sqrt{n}$-approximation ratio. We prove that the algorithm always produces a valid independent set, using an $O\left(m\right)$ is_independent_set subroutine and a NetworkX implementation with adjacency list representation.

Theorem 1.

The hybrid maximum independent set algorithm, which combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections, a low-degree induced subgraph heuristic, a greedy extension on the tree-based candidate, and uses an $O\left(m\right)$is_independent_setsubroutine, always produces a valid independent set for any undirected graph $G=(V,E)$. That is, the output set $S\subseteq V$ satisfies the property that no two vertices in S are adjacent.

Proof. 

To prove correctness, we show that the output S is an independent set, i.e., for all $u,v\in S$, $(u,v)\notin E$. We analyze each case of the algorithm’s execution.

3.2. Case 1: Trivial Cases

If G has no vertices ($n=0$) or no edges ($m=0$), the algorithm returns $S=V$.

• If $n=0$, $S=\varnothing$. The empty set is an independent set, as it contains no vertices to be adjacent.
• If $m=0$, $S=V$. Since there are no edges, no pair of vertices is adjacent, so V is an independent set.

3.3. Case 2: Graph with Only Isolated Nodes

After preprocessing, if the graph has no edges (all vertices are isolated), the algorithm returns isolates, the set of all vertices with degree 0. Since $G\left[\mathrm{isolates}\right]$ has no edges, this set is independent.

3.4. Case 3: Bipartite Graph

If G is bipartite, the algorithm computes the maximum independent set for each connected component using iset_bipartite:

• For each component with vertex set $V_C$, it uses the Hopcroft-Karp algorithm to find a maximum matching, then computes a minimum vertex cover C using König’s theorem.
• The independent set is $V_C\setminus C$, the complement of the vertex cover in the component.
• By König’s theorem, in a bipartite graph, the complement of a minimum vertex cover is a maximum independent set. If any two vertices in $V_C\setminus C$ were adjacent, they would form an edge not covered by C, contradicting the vertex cover property.
• The union of these sets across components is independent in G, as components are disconnected.

3.5. Case 4: Non-Bipartite Graph

For non-bipartite graphs, the algorithm computes four independent sets and returns the largest:

1.

Iterative Refinement:

• Start with $S_0=V$, where V is the set of non-isolated vertices after preprocessing.
• While $S_k$ is not independent in G, compute $S_{k+1}$ as the maximum independent set of a maximum spanning tree $T_k$ of $G\left[S_k\right]$, using iset_bipartite.
• Stop when $S_t$ is independent in G, verified by is_independent_set.
• Greedily extend $S_t$ by iterating over remaining vertices and adding each if it has no neighbors in the current set.
• Output $S_{\mathrm{iterative}}=S_{\mathrm{extended}}$.

2.

Greedy Minimum-Degree Selection: Sort vertices by increasing degree and add each vertex v to $S_{\min -\mathrm{greedy}}$ if it has no neighbors in the current set. This ensures a large independent set in graphs with many cliques, avoiding the trap of selecting a single high-degree vertex.

3.

Greedy Maximum-Degree Selection: Sort vertices by decreasing degree and add each vertex v to $S_{\max -\mathrm{greedy}}$ if it has no neighbors in the current set. This helps in graphs where high-degree vertices form a large independent set connected to low-degree cliques.

4.

Low-Degree Induced Subgraph: Compute the induced subgraph on vertices with degree less than the maximum degree, then apply minimum-degree greedy to obtain $S_{\mathrm{low}}$.

5.

Output: Return $S=S_{\mathrm{iterative}}$ if $|S_{\mathrm{iterative}}|$ is largest, else the largest among $S_{\min -\mathrm{greedy}}\cup \mathrm{isolates}$, $S_{\max -\mathrm{greedy}}\cup \mathrm{isolates}$, or $S_{\mathrm{low}}\cup \mathrm{isolates}$.

3.5.1. Iterative Refinement

The iterative loop terminates when $S_t$ is independent in G:

• is_independent_set returns True if and only if no edge $(u,v)\in E$ has both $u,v\in S_t$, taking $O\left(m\right)$ time by checking all edges.
• Thus, $S_t$ is an independent set in G.

3.5.2. Greedy Extension in Iterative Refinement

The extension starts with independent $S_t$ and adds remaining vertices:

• Iterate over all vertices $v\notin S_t$.
• Add v if no edge $(v,u)$ for $u\in S_t$.
• Each addition preserves independence, as the check ensures no new adjacencies.
• Thus, the extended $S_{\mathrm{iterative}}$ is independent.

3.5.3. Greedy Minimum-Degree Selection

The greedy approach builds $S_{\min -\mathrm{greedy}}$:

• Vertices are sorted by degree, and for each vertex v, it is added to $S_{\min -\mathrm{greedy}}$ if none of its neighbors are in the current set.
• At each step, the check ensures that adding v introduces no edges, as $(v,u)\notin E$ for all $u\in S_{\min -\mathrm{greedy}}$.
• The resulting $S_{\min -\mathrm{greedy}}$ is independent, as each addition preserves the property that no two vertices in the set are adjacent.

3.5.4. Greedy Maximum-Degree Selection

Similarly, for $S_{\max -\mathrm{greedy}}$:

• Vertices are sorted by decreasing degree, and each v is added if no neighbors are in the current set.
• Each addition preserves independence, so $S_{\max -\mathrm{greedy}}$ is independent.

3.5.5. Low-Degree Induced Subgraph

The low-degree set $S_{\mathrm{low}}$ is computed using minimum-degree greedy on the induced subgraph, which by the above preserves independence in the subgraph, hence in G.

3.5.6. Final Output

The algorithm selects the largest among $S_{\mathrm{iterative}}$, $S_{\min -\mathrm{greedy}}$, $S_{\max -\mathrm{greedy}}$, and $S_{\mathrm{low}}$, then unions with isolates:

• All four are independent in the non-isolated subgraph.
• Isolated vertices have degree 0, so adding them introduces no edges.
• Thus, the final S remains independent.

3.6. Conclusion

In all cases, the output is independent, verified by the $O\left(m\right)$ subroutine.    □

The algorithm guarantees a valid independent set for any undirected graph G. Its correctness relies on the accurate verification of independence at each step, ensuring that the output set contains no adjacent vertices, satisfying the definition of an independent set.