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 set of 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\left(\Delta \right)$, 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 three 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}}$.

The algorithm selects the largest of $S_{\mathrm{iterative}}$, $S_{\min -\mathrm{greedy}}$, and $S_{\max -\mathrm{greedy}}$, 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.

Algorithm Description

Figure A1 presents the core implementation. The hybrid algorithm combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections, returning the largest independent set 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 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.

Case 1: Trivial Cases

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

• 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.

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.

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.

Case 4: Non-Bipartite Graph

For non-bipartite graphs, the algorithm computes three 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$: for each $u\in V$, if $S_t\cup \left\{u\right\}$ is independent, add u. Output $S_{\mathrm{iterative}}$.

(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.

(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.

(4)

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

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.
• Greedy Extension: For each vertex $u\in V$, if $S_t\cup \left\{u\right\}$ is independent (verified by is_independent_set), add u. This ensures no edge exists between u and any vertex in $S_t$, or between any pair in the updated set. Each addition preserves independence, so $S_{\mathrm{iterative}}$ is independent.

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.

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.

Final Output

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

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

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.

Proof of $\sqrt{n}$-Approximation Ratio for Hybrid Maximum Independent Set Algorithm

Let OPT denote the size of the maximum independent set. The algorithm combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections, returning the largest independent set to guarantee a $\sqrt{n}$-approximation ratio across all graphs, including those with multiple cliques sharing a universal vertex.

Theorem 2.The hybrid maximum independent set algorithm, which combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections, has an approximation ratio of $\sqrt{n}$. That is, if S is the independent set returned and OPT is the size of the maximum independent set, then ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}\le \sqrt{n}$.

Proof. We show that ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}\le \sqrt{n}$ by describing the hybrid algorithm and analyzing its performance on key graphs, including worst-case scenarios for each component method where the iterative refinement or one of the greedy approaches may perform poorly, but the selection of the largest ensures the bound.

Algorithm Description

The algorithm operates as follows:

(1)

Preprocessing: Remove self-loops and isolated nodes from G. Let $I_{\mathrm{iso}}$ be the set of isolated nodes. If the graph is empty or edgeless, return $I_{\mathrm{iso}}$.

(2)

Iterative Refinement:

(a)

Start with $S_0=V$, where V is the set of non-isolated vertices.

(b)

While $S_k$ is not an independent set in G:

• Construct a maximum spanning tree $T_k$ of the subgraph $G\left[S_k\right]$.
• Compute the maximum independent set of $T_k$ (a tree, thus bipartite) using a matching-based approach, and set $S_{k+1}$ to this set.

(c)

Stop when $S_t$ is independent in G.

(d)

Greedily extend $S_t$: for each $u\in V$, if $S_t\cup \left\{u\right\}$ is independent, add u. Let $S_{\mathrm{iterative}}=S_t$.

(3)

Greedy Selections: Compute $S_{\min -\mathrm{greedy}}$ by sorting vertices by increasing degree and adding each vertex v if it has no neighbors in the current set. Compute $S_{\max -\mathrm{greedy}}$ by sorting vertices by decreasing degree and adding each vertex v if it has no neighbors in the current set.

(4)

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

Since $T_k$ is a tree with $|S_k|$ vertices, its maximum independent set has size at least $\lceil \left|S_k\right|/2\rceil$. All three sets ($S_{\mathrm{iterative}}$, $S_{\min -\mathrm{greedy}}$, $S_{\max -\mathrm{greedy}}$) are maximal independent sets in the non-isolated subgraph, and S is maximal in G.

Approximation Ratio Analysis

We analyze specific worst-case graphs for each method to establish the $\sqrt{n}$-approximation ratio, demonstrating how the hybrid selection mitigates individual weaknesses.

Worst-Case for Iterative Refinement

Consider a graph $G=(V,E)$ with n vertices, generalized to:

• A clique C of size $n-\sqrt{n}+1$.
• An independent set I of size $\left|I\right|=\sqrt{n}$, assuming $\sqrt{n}$ is an integer.
• All edges between C and I.

The maximum independent set is I, with $\mathrm{OPT}=\sqrt{n}$. The iterative approach may:

• Start with $S_0=V$, $|S_0|=n$.
• In each iteration, the maximum spanning tree favors dense connections in C, forming a star-like structure centered in C, reducing the set size by approximately half but converging slowly to select a single vertex from C, yielding $S_{\mathrm{iterative}}=\left\{v\right\}$, $|S_{\mathrm{iterative}}|=1$.
• Greedy extension adds no further vertices due to full connectivity to I.

Thus, ${\displaystyle \frac{\mathrm{OPT}}{|S_{\mathrm{iterative}}|}}=\sqrt{n}$. However, the max-degree greedy (detailed below) recovers I, ensuring the hybrid selects a size-$\sqrt{n}$ set.

Worst-Case for Minimum-Degree Greedy

Consider a graph with a large low-degree independent set L ($\left|L\right|=\sqrt{n}$, degree 1 each, connected sparsely to a high-degree clique H of size $n-\sqrt{n}$). Vertices in L have low degree (1), while H vertices have high degree ($\approx n$). The min-degree greedy processes L first but, due to sparse connections, may add all of L initially; however, in a variant where L vertices are connected in a way that early additions block later ones (e.g., a matching within low-degree parts), it selects only 1 from L, yielding $|S_{\min -\mathrm{greedy}}|=1$. The ratio is $\sqrt{n}$, but the tree-based method, by constructing a spanning tree that exposes the bipartite structure between L and H, computes a maximum independent set of size $\sqrt{n}$ (preferring L), overcoming this by selecting the large low-degree set.

Worst-Case for Maximum-Degree Greedy

Consider the reverse: a large high-degree independent set H ($\left|H\right|=\sqrt{n}$, each connected to all of a low-degree clique L of size $n-\sqrt{n}$). Vertices in H have high degree ($n-\sqrt{n}$), while L has low degree (within clique plus sparse). The max-degree greedy starts with H, adding one from H (since independent), but subsequent H vertices are added fully as no edges within H; wait, in this case it succeeds. To worsen: add edges such that high-degree vertices in a small clique K ($\left|K\right|=n-\sqrt{n}$, high degree due to dense connections), and I low-degree independent set. Max-greedy picks one from K first, blocking the low-degree I, yielding size 1. Ratio $\sqrt{n}$. The tree-based method overcomes by building a spanning tree that balances the structure, selecting the full I via bipartite MIS computation.

Best Counterexample Candidate via Worst-Case Graph

Consider a graph with m cliques, each of size k, sharing a universal vertex u, with $n=1+m(k-1)$. The maximum independent set includes one vertex per clique (excluding u), so $\mathrm{OPT}=m\approx n/(k-1)$. For $k=3$, $m\approx n/2$.

• Iterative Approach: May reduce to $S_{\mathrm{iterative}}=\left\{u\right\}$, $|S_{\mathrm{iterative}}|=1$, giving a ratio of ${\displaystyle \frac{\mathrm{OPT}}{|S_{\mathrm{iterative}}|}}\approx n/(k-1)$, e.g., $n/2$ for $k=3$, which exceeds $\sqrt{n}$.
• Min-Greedy Approach: Selects vertices in minimum-degree order. Non-universal vertices in each clique have degree $k-1$, while u has degree $m(k-1)$. The algorithm picks one vertex per clique, yielding $S_{\min -\mathrm{greedy}}$ of size m, so ${\displaystyle \frac{\mathrm{OPT}}{|S_{\min -\mathrm{greedy}}|}}={\displaystyle \frac{m}{m}}=1$.
• Max-Greedy Approach: Starts with high-degree u, then skips cliques, but may recover one per clique in subsequent steps, yielding size m.
• The algorithm outputs the largest S (size m), with ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}=1\le \sqrt{n}$.

General Case

In general:

• $\left|S\right|\ge 1$ (assuming G has non-isolated vertices).
• If $\mathrm{OPT}\le \sqrt{n}$, then ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}\le \mathrm{OPT}\le \sqrt{n}$, as $\left|S\right|\ge 1$.
• If $\mathrm{OPT}>\sqrt{n}$, the ratio is often better. In bipartite graphs ($\mathrm{OPT}\approx n/2$), the iterative approach finds an optimal set, giving a ratio of 1. In cycle graphs ($\mathrm{OPT}=\lceil n/2\rceil$), either approach yields $\left|S\right|\approx n/2$, with a ratio near 1. In the counterexample, the greedy approaches ensure $\left|S\right|\approx n/(k-1)$, giving a ratio of $k-1$ (e.g., 2 for $k=3$). Since $\mathrm{OPT}\le n$, the ratio is at most $n/\left|S\right|$, and the worst case occurs when $\mathrm{OPT}=\sqrt{n}$, $\left|S\right|=1$, yielding $\sqrt{n}$.

The hybrid approach ensures ${\displaystyle \frac{\mathrm{OPT}}{\left|S\right|}}\le \sqrt{n}$ by selecting the largest set, where the tree-based method overcomes greedy pitfalls in degree-biased scenarios by leveraging structural bipartiteness in spanning trees, covering all cases.    □

The hybrid algorithm guarantees a maximal independent set with a worst-case approximation ratio of $\sqrt{n}$, as shown by the analysis of the worst-case graphs for each component and the counterexample ($\mathrm{OPT}\approx n/(k-1)$, $\left|S\right|\approx n/(k-1)$). The multi-heuristic selection ensures robustness across diverse graph structures.

Runtime Analysis of the Maximum Independent Set Algorithm

The hybrid algorithm combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections, returning the largest independent set to achieve a $\sqrt{n}$-approximation ratio. We prove its worst-case time complexity is $O(nmlogn)$, using a NetworkX implementation with an $O\left(m\right)$ is_independent_set subroutine and adjacency list representation.

Theorem 3.The hybrid maximum independent set algorithm, which combines iterative refinement using maximum spanning trees with greedy minimum-degree and maximum-degree selections and uses an $O\left(m\right)$is_independent_setsubroutine, has a worst-case time complexity of $O(nmlogn)$, where $n=\left|V\right|$ and $m=\left|E\right|$.

Proof. We analyze the time complexity of each step for a graph $G=(V,E)$ with n vertices and m edges, assuming NetworkX operations and an adjacency list representation, where edge iterations take $O\left(m\right)$ and vertex iterations take $O\left(n\right)$.

Step 1: Input Validation

Checking if the input is a NetworkX graph (type checking) takes $O\left(1\right)$ time.

Step 2: Preprocessing

• Graph Copy: Copying the graph takes $O(n+m)$, duplicating vertices and edges in the adjacency list.
• Self-Loop Removal: Identifying and removing self-loops via nx.selfloop_edges takes $O\left(m\right)$, checking each edge.
• Isolated Nodes: Identifying isolates (degree 0) takes $O\left(n\right)$ by checking each vertex’s degree. Removing them takes $O\left(n\right)$.
• Empty Graph Check: Checking if the graph has no nodes or edges takes $O\left(1\right)$. Returning the isolates set takes $O\left(n\right)$.

Total preprocessing time: $O(n+m)$.

Step 3: Bipartite Check

Testing if the graph is bipartite using breadth-first search (BFS) takes $O(n+m)$, traversing all vertices and edges once.

Step 4: Bipartite Case

If the graph is bipartite, the iset_bipartite subroutine is called:

• Connected Components: Finding components via BFS or DFS takes $O(n+m)$.
• Per Component: For a component with $n_i$ vertices and $m_i$ edges ($\sum n_i\le n$, $\sum m_i\le m$):
  • Subgraph Extraction: Takes $O(n_i+m_i)$.
  • Hopcroft-Karp Matching: Computing a maximum matching takes $O\left(\sqrt{n_i}{m}_i\right)$.
  • Vertex Cover: Converting the matching to a minimum vertex cover takes $O\left(n_i\right)$.
  • Set Operations: Computing the complement of the vertex cover and updating the independent set takes $O\left(n_i\right)$.
  Total per component: $O(n_i+m_i+\sqrt{n_i}{m}_i)$.
• Across Components: Summing, $\sum (n_i+m_i)=O(n+m)$, and $\sum \sqrt{n_i}{m}_i\le \sqrt{n}\sum m_i\le \sqrt{n}m$, since $\sqrt{n_i}\le \sqrt{n}$. Thus, total time is $O(n+m+\sqrt{n}m)$.

Total bipartite case: $O(n+m+\sqrt{n}m)$.

Step 5: Non-Bipartite Case

For non-bipartite graphs, the algorithm computes three independent sets and selects the largest.

Iterative Refinement

• is_independent_set: Checks all edges in $O\left(m\right)$, returning False if any edge has both endpoints in the set.
• Maximum Spanning Tree: Using Kruskal’s algorithm on $G\left[S_k\right]$ with up to n vertices and m edges takes $O(mlogn)$, dominated by edge sorting.
• iset_bipartiteon Tree: The spanning tree $T_k$ has at most $n-1$ edges. Computing its maximum independent set takes $O\left(n\right)$, as:
  • Components: $O\left(n\right)$ (tree is connected or trivial).
  • BFS-based coloring for bipartite tree: $O\left(n\right)$, simpler than Hopcroft-Karp.
  • Vertex cover and set operations: $O\left(n\right)$.
• Number of Iterations: In the worst case, the set reduces by at least 1 vertex per iteration (e.g., star tree removes one vertex). Starting from $|S_0|=n$, the loop runs at most $O\left(n\right)$ times.
• Total per Iteration: $O(m+mlogn+n)=O(mlogn)$.
• Total Loop: $O(n·mlogn)$.

Total iterative refinement: $O(nmlogn)$.

Greedy Extension

• For each of n vertices, check if $S_t\cup \left\{u\right\}$ is independent using is_independent_set, taking $O\left(m\right)$.
• Set operations (union, addition) take $O\left(1\right)$ amortized per vertex.
• Total: $O\left(n·m\right)$.

Total iterative approach: $O(nmlogn+nm)=O(nmlogn)$.

Greedy Minimum-Degree and Maximum-Degree Selections

• Sorting Vertices: Sorting n vertices by degree takes $O(nlogn)$ for each.
• Selection: For each of n vertices, check neighbors (up to m edges total) to ensure independence, taking $O\left(m\right)$ across all vertices for each.
• Set Operations: Adding vertices to the set takes $O\left(1\right)$ amortized, so $O\left(n\right)$ total per greedy.
• Total per greedy: $O(nlogn+m+n)=O(nlogn+m)$.
• For two greeds: $O\left(2\right(nlogn+m\left)\right)=O(nlogn+m)$.

Step 6: Final Selection

Comparing the sizes of the three solutions and selecting the largest takes $O\left(1\right)$. Adding isolates to the final set takes $O\left(n\right)$.

Overall Complexity

Combining all steps:

• Preprocessing: $O(n+m)$.
• Bipartite check: $O(n+m)$.
• Bipartite case: $O(n+m+\sqrt{n}m)$.
• Non-bipartite case:
  • Iterative refinement: $O(nmlogn)$.
  • Greedy selections: $O(nlogn+m)$.
• Final selection and isolates: $O\left(n\right)$.

The dominant term is the non-bipartite iterative refinement, $O(nmlogn)$. The greedy selections’ $O(nlogn+m)$ is subsumed, as $nlogn+m\le nmlogn$ for $m\ge 1$. For dense graphs ($m=O\left(n^2\right)$), the complexity is $O(n^{3}logn)$; for sparse graphs ($m=O\left(n\right)$), it is $O(n^{2}logn)$. Thus, the worst-case time complexity is $O(nmlogn)$.    □

Experimental Results

We present a rigorous evaluation of our approximate algorithm for the maximum independent set problem using complement graphs from the DIMACS benchmark suite. Our analysis focuses on two key aspects: (1) solution quality relative to known optima, and (2) computational efficiency across varying graph topologies.

Experimental Setup and Methodology

We employ the complementary instances from the Second DIMACS Implementation Challenge [7], selected for their:

• Structural diversity: Covering random graphs (C-series), geometric graphs (MANN), and complex topologies (Keller, brock).
• Computational hardness: Established as challenging benchmarks in prior work [8,9].
• Known optima: Enabling precise approximation ratio calculations.

The test environment consisted of:

• Hardware: 11th Gen Intel® Core™ i7-1165G7 (2.80 GHz), 32GB DDR4 RAM.
• Software: Windows 10 Home, Furones: Approximate Independent Set Solver v0.0.6 [6].
• Methodology:
  • A single run per instance.
  • Solution verification against published clique numbers.
  • Runtime measurement from graph loading to solution output.

Our evaluation compares achieved independent set sizes against:

• Optimal solutions (where known) via complement graph transformation.
• Theoretical $\sqrt{n}$ approximation bound, where n is the number of vertices of the graph instance.
• Instance-specific hardness parameters (density, regularity).

Performance Metrics

We evaluate the performance of our algorithm using the following metrics:

(1)

Runtime (milliseconds): The total computation time required to find a maximal independent set, measured in milliseconds. This metric reflects the algorithm’s efficiency across graphs of varying sizes and densities, as shown in Table 2.

(2)

Approximation Quality: We quantify solution quality through two complementary measures:

• Approximation Ratio: For instances with known optima, we compute:

  $$\rho ={\displaystyle \frac{\left|OPT\right|}{\left|ALG\right|}}$$

  where:
  • $\left|OPT\right|$: The optimal independent set size (equivalent to the maximum clique in the complement graph).
  • $\left|ALG\right|$: The solution size found by our algorithm.
  A ratio $\rho =1$ indicates optimality, while higher values suggest room for improvement. Our results show ratios ranging from 1.0 (perfect) to 1.8 (suboptimal) across DIMACS benchmarks.

Results and Analysis

The experimental results for a subset of the DIMACS instances are summarized in Table 2.

Our analysis of the DIMACS benchmark results yields the following key insights:

• Runtime Performance: The algorithm demonstrates varying computational efficiency across graph classes:
  • Sub-second performance on small dense graphs (e.g., C125.9 in 30.57 ms, keller4 in 298.87 ms).
  • Minute-scale computations for mid-sized challenging instances (e.g., keller6 in 404,500 ms, p_hat1500-1 in 553,791 ms).
  • Hour-long runs for the largest instances (e.g., C4000.5 in 3,731,507 ms).
  Runtime correlates strongly with both graph size ($\sqrt{n}$) and approximation difficulty - instances requiring higher approximation ratios (e.g., Keller graphs with $\rho >1.4$) consistently demand more computation time than similarly-sized graphs with better ratios.
• Solution Quality: The approximation ratio $\rho ={\displaystyle \frac{\left|OPT\right|}{\left|ALG\right|}}$ reveals three distinct performance regimes:
  • Optimal solutions ($\rho =1.0$) for structured graphs:
    • Hamming graphs (hamming8-4, hamming10-4).
    • MANN graphs (near-optimal with $\rho <1.01$).
  • Good approximations ($1.0<\rho \le 1.3$) for:
    • Random graphs (C125.9, C250.9).
    • Sparse instances (p_hat300-3, p_hat700-3).
  • Challenging cases ($\rho >1.4$) requiring improvement:
    • Brockington graphs (brock200_2 $\rho =1.714$).
    • Keller graphs (keller5 $\rho =1.421$, keller6$\rho =1.553$).

The results demonstrate that our algorithm achieves particularly strong performance on graphs with regular structure (Hamming, MANN) while facing challenges on highly irregular topologies (Keller, brock). The runtime-accuracy trade-off follows predictable patterns, with computation time growing polynomially with problem size while maintaining approximation guarantees consistent with theoretical expectations.

Discussion and Implications

Our experimental results reveal several important trade-offs and practical considerations:

• Quality-Efficiency Tradeoff: The algorithm achieves perfect solutions ($\rho =1.0$) for structured graphs like Hamming and MANN instances while maintaining reasonable runtimes (e.g., hamming8-4 in 658 ms, MANN_a27 in 219 ms). However, the computational cost grows significantly for difficult instances like keller6 (404,500 ms) and C4000.5 (3,731,507 ms), suggesting a clear quality-runtime tradeoff.
• Structural Dependencies: Performance strongly correlates with graph topology:
  • Excellent on regular structures (Hamming, MANN).
  • Competitive on random graphs (C-series with $\rho \approx 1.3$).
  • Challenging for irregular dense graphs (Keller, brock with $\rho >1.4$).
• Practical Applications: The demonstrated performance makes this approach particularly suitable for:
  • Circuit design applications (benefiting from perfect Hamming solutions).
  • Scheduling problems (leveraging near-optimal MANN performance).
  • Network analysis where $\sqrt{n}$-approximation is acceptable.

Future Work

Building on these results, we identify several promising research directions:

• Hybrid Approaches: Combining our algorithm with fast heuristics for initial solutions on difficult instances (e.g., brock and Keller graphs) to reduce computation time while maintaining quality guarantees.
• Parallelization: Developing GPU-accelerated versions targeting the most time-consuming components, particularly for large sparse graphs like p_hat1500 series and C4000.5.
• Domain-Specific Optimizations: Creating specialized versions for:
  • Perfect graphs (extending our success with Hamming codes).
  • Geometric graphs (improving on current ratios).
• Extended Benchmarks: Evaluation on additional graph classes:
  • Real-world networks (social, biological).
  • Massive sparse graphs from web analysis.
  • Dynamic graph scenarios.

Conclusion

The hybrid maximum independent set algorithm, designed for an undirected graph $G=(V,E)$ with n vertices and m edges, achieves a $\sqrt{n}$-approximation ratio with a time complexity of $O(nmlogn)$. It combines three strategies: iterative refinement, which constructs maximum spanning trees of induced subgraphs, computes their maximum independent sets (leveraging the bipartite nature of trees), and applies a greedy extension; greedy minimum-degree selection, which builds an independent set by adding vertices in increasing degree order; and greedy maximum-degree selection, which adds vertices in decreasing degree order. The algorithm selects the largest of the three resulting sets, ensuring a valid, maximal independent set. An $O\left(m\right)$is_independent_set subroutine verifies independence, enhancing efficiency for sparse graphs. This hybrid approach is robust, handling diverse graph structures, including those with multiple cliques sharing a universal vertex, and is implemented using standard NetworkX operations. Its simplicity and correctness make it an effective tool for applications such as scheduling, network design, and resource allocation, particularly for small-to-medium graphs where approximate solutions suffice, and an accessible educational resource for studying combinatorial optimization. Achieving a good approximation ratio is difficult, with the best polynomial-time algorithms often yielding ratios like $O(n/logn)$ or worse due to the problem’s complexity. An approximation algorithm for the Maximum Independent Set problem with an approximation factor of $\sqrt{n}$ would imply $P=NP$. This is because the Maximum Independent Set problem is known to be NP-hard, and it is hard to approximate within a factor of $O\left(n^{1-ϵ}\right)$ for any $ϵ>0$ unless $P=NP$ [5]. A hypothetical breakthrough proving $\mathrm{P}=\mathrm{NP}$ would profoundly transform computer science and related fields [10].

Acknowledgments: The author would like to thank Iris, Marilin, Sonia, Yoselin, and Arelis for their support.

Figure A1. Python implementation of a $\sqrt{n}$-approximation algorithm for Maximum Independent Set in polynomial time.

Figure A1. Python implementation of a $\sqrt{n}$-approximation algorithm for Maximum Independent Set in polynomial time.

Figure A2. Python implementation of the subroutines used in our polynomial-time $\sqrt{n}$-approximation algorithm for Maximum Independent Set.

Figure A2. Python implementation of the subroutines used in our polynomial-time $\sqrt{n}$-approximation algorithm for Maximum Independent Set.