An Approximate Solution to the Minimum Vertex Cover Problem: The Hvala Algorithm

1. Introduction

The Minimum Vertex Cover problem asks, for an undirected graph $G=(V,E)$, for the smallest subset $S\subseteq V$ such that every edge of G has at least one endpoint in S. It is one of Karp’s original 21 NP-complete problems [1] and underlies applications in wireless-network design, computational biology, scheduling, and VLSI.

Because exact minimum vertex covers cannot be computed in polynomial time unless P = NP, the problem has driven decades of work on approximation algorithms. The classical 2-approximation obtained by taking both endpoints of every edge of a maximal matching is folklore [2]; LP-based refinements by Karakostas [3] and Karpinski and Zelikovsky [4] reach factor $2-\Theta (1/\sqrt{logn})$, which is $2-o\left(1\right)$ but does not match a constant $2-ϵ$. From the hardness side, Dinur and Safra [5] ruled out ratio below $1.3606$ under P ≠ NP; Khot, Minzer and Safra [6,7,8] strengthened this to $\sqrt{2}-ϵ$ under the Strong Exponential Time Hypothesis (SETH); and, under the Unique Games Conjecture [9], no constant factor below $2-ϵ$ is achievable [10]. A polynomial-time algorithm with constant ratio $\rho <\sqrt{2}$ would therefore resolve P versus NP, and already an unconditional $2-ϵ$ constant is considered beyond reach of current techniques.

Scope and contribution. Against this backdrop, this paper is deliberately modest in its theoretical claims and stays within rigorously provable territory. The contributions are:

1.

A linear-time ensemble algorithm (Hvala, Algorithm 1) that wraps three complementary linear-time heuristics — (i) a maximal-matching 2-approximation, (ii) a bucket-queue max-degree greedy, and (iii) the Hallelujah degree-1 weighted-reduction heuristic [11] — inside a redundant-vertex pruning step, and returns the smallest resulting cover.

2.

A rigorous proof (Theorem 2) that Hvala achieves worst-case approximation ratio $\rho \le 2$ on every finite simple graph. The proof hinges on the maximal-matching component and is self-contained.

3.

A strict pointwise inequality $\left|S\right|<2·\mathrm{OPT}\left(G\right)$ on every finite simple graph (Corollary 1), inherited from the companion paper [11]. The Hallelujah heuristic’s approximation ratio is asymptotic to 2 — strictly less than 2 on each graph, with supremum equal to 2 — so no constant strictly smaller than 2 bounds it uniformly; but the pointwise strict inequality on each graph is preserved by the minimum-selection and pruning steps of Hvala.

4.

An empirical evaluation on two independent experimental studies totalling 239 instances: 109 structured hard instances from the NPBench benchmark collection [12] (41 FRB hard random graphs and 68 DIMACS clique-complement graphs, all with known optima) and 130 real-world large graphs from the Network Data Repository [13] (biological, social, collaboration, web, infrastructure, and scientific-computing networks, reaching up to $2,523,386$ vertices and $15,245,729$ edges), reporting solution quality, running time, and a breakdown by graph family.

The remainder of the paper is organised as follows. Section 3 describes the Hvala algorithm in detail. Section 4 establishes the linear-time complexity. Section 5 contains the approximation-ratio analysis (rigorous $\le 2$ bound and the strict pointwise $<2$ inheritance). Section 6 reports two experimental studies: the NPBench structured-hard-instance benchmark (Section 6.1) and a real-world large-graph benchmark drawn from the Network Data Repository (Section 6.2). Section 7 discusses the empirical–theoretical gap, hardness barriers, and the prospects of Hvala as a candidate for refined analysis below the $\sqrt{2}$ threshold on restricted graph classes (Section 7.3); Section 8 concludes.

2. Research Data and Implementation

To facilitate reproducibility and community adoption, we developed the open-source Python package Hvala: Approximate Vertex Cover Solver, available via the Python Package Index (PyPI) [14]. This implementation encapsulates the full ensemble algorithm — including the maximal-matching 2-approximation, the bucket-queue max-degree greedy, the Hallelujah degree-1 weighted-reduction subroutine, and the redundant-vertex pruning post-processing step — while guaranteeing an approximation ratio at most 2 (with pointwise strict inequality $<2$ on every finite simple graph) through rigorous validation. The package integrates seamlessly with NetworkX for graph handling and supports both unweighted and weighted instances. Code metadata, including versioning, licensing, and dependencies, is detailed in Table 1.

3. The Hvala Algorithm

3.1. Overview

Given a simple undirected graph $G=(V,E)$, Hvala first performs trivial preprocessing (remove self-loops and isolated vertices) and then computes four candidate vertex covers:

$C_1$ —

Maximal-matching cover. Compute a maximal matching M of G and let $C_1={\bigcup }_{(u,v)\in M}\{u,v\}$. This is the classical 2-approximation of [2].

$C_2$ —

Bucket-queue max-degree greedy. Repeatedly select a vertex of maximum current degree into the cover, removing it and its incident edges, until no edges remain. Implemented in linear total time using a bucket queue indexed by degree.

$C_3$ —

Hallelujah degree-1 reduction. Build an auxiliary graph $G^{\prime }$ by splitting every vertex u of degree k into k auxiliary copies $(u,0),\dots ,(u,k-1)$, each connected to exactly one of u’s neighbours, and assigning weight $1/k$ to every such auxiliary vertex. $G^{\prime }$ has maximum degree at most 1 on the auxiliary side, so a minimum weighted vertex cover on $G^{\prime }$ is obtained by picking, per edge of $G^{\prime }$, the endpoint of smaller weight (with lexicographic tie-breaking). Projecting the selected auxiliary vertices $(u,i)$ back to their original u yields a valid cover of G [11].

${\tilde{C}}_4$ —

Pruned union. Start from $C_1\cup C_2\cup C_3$ and apply redundant-vertex pruning (Algorithm 6) once, directly yielding the fourth candidate ${\tilde{C}}_4$.

The candidates $C_1,C_2,C_3$ are then each individually passed through redundant-vertex pruning to obtain ${\tilde{C}}_1,{\tilde{C}}_2,{\tilde{C}}_3$, and the algorithm returns the smallest among ${\tilde{C}}_1,{\tilde{C}}_2,{\tilde{C}}_3,{\tilde{C}}_4$. Note that $C_1$ is included as a worst-case safety net: its value is guaranteed to be at most $2·\mathrm{OPT}$, and since the algorithm returns $min(\left|{\tilde{C}}_1\right|,\left|{\tilde{C}}_2\right|,\left|{\tilde{C}}_3\right|,\left|{\tilde{C}}_4\right|)$, this guarantee propagates to the final output regardless of how $C_2$, $C_3$, and the union behave.

3.2. Main Algorithm

3.3. Subroutines

4. Complexity Analysis

Theorem 1

(Linear-time and linear-space). Hvala runs in $\mathcal{O}(n+m)$ time and $\mathcal{O}(n+m)$ space, where $n=\left|V\right|$ and $m=\left|E\right|$.

Proof. 

Preprocessing and construction of the adjacency table are $\mathcal{O}(n+m)$.

Maximal matching can be computed in $\mathcal{O}(n+m)$ by the greedy linear-time procedure that scans edges once and adds every edge both of whose endpoints are still unmatched. Building $C_1$ from M is $\mathcal{O}\left(\right|M\left|\right)\le \mathcal{O}\left(m\right)$.

Bucket-queue max-degree greedy. Each vertex is inserted into a bucket at most once per decrement of its degree; across the whole execution the total number of bucket insertions is bounded by ${\sum }_{v}deg\left(v\right)=2m$, and each insertion/removal is $\mathcal{O}\left(1\right)$. The outer loop over d performs $\mathcal{O}(\Delta )\le \mathcal{O}\left(n\right)$ constant-time bucket checks. Total time: $\mathcal{O}(n+m)$.

Hallelujah reduction. The auxiliary graph $G^{\prime }$ has exactly $2m$ vertices and m edges (one edge per edge of G, with auxiliary vertices added on both endpoints when both are of positive degree). MinVCDegree1 visits every vertex once and its single neighbour once, hence runs in $\mathcal{O}\left(\right|V\left(G^{\prime }\right)|+|E\left(G^{\prime }\right)\left|\right)=\mathcal{O}(n+m)$.

Pruning. For each $v\in C$, checking whether all neighbours are in C is $\mathcal{O}(deg(v\left)\right)$; summed over all $v\in C\subseteq V$ the total work is at most ${\sum }_{v\in V}deg\left(v\right)=2m$. Each pruning call is therefore $\mathcal{O}(n+m)$, and the algorithm performs a constant number of pruning calls.

Space is dominated by the adjacency table and the auxiliary graph $G^{\prime }$, both $\mathcal{O}(n+m)$.    □

5. Approximation Ratio Analysis

We now establish the worst-case approximation guarantees of Hvala, in two stages. First, a self-contained proof that Hvala always returns a cover of size at most $2·\mathrm{OPT}$ (Theorem 2); this is the baseline guarantee. Second, an inheritance argument (Corollary 1) showing that Hvala satisfies the strict pointwise inequality $\left|S\right|<2·\mathrm{OPT}\left(G\right)$ on every finite simple graph G, mirroring the analogous property proved for the Hallelujah heuristic in the companion paper [11]. Both statements are needed: Theorem 2 gives the absolute $\le 2$ bound, while Corollary 1 records that the inequality is in fact strict on each graph, even though — as explained in Section 5.3 below — the supremum of the ratio over all graphs still equals 2.

Throughout this section, $G=(V,E)$ is a finite simple undirected graph without self-loops, and $\mathrm{OPT}\left(G\right)$ denotes the size of a minimum vertex cover of G. Isolated vertices contribute 0 to $\mathrm{OPT}$, so removing them (as the algorithm does in preprocessing) leaves $\mathrm{OPT}$ unchanged.

5.1. A Lemma about Redundant-Vertex Pruning

Lemma 1

(Pruning preserves validity and never increases size). Let C be a vertex cover of G and let $C^{\prime }=PruneRedundant(\mathrm{adj},C)$. Then $C^{\prime }\subseteq C$ and $C^{\prime }$ is also a vertex cover of G.

Proof. 

That $C^{\prime }\subseteq C$ is clear from the procedure (it only ever removes elements).

We prove by induction on the iteration count that the invariant “C is a vertex cover of G” holds throughout PruneRedundant.

Base case. At the start, C is a vertex cover of G by hypothesis.

Inductive step. Suppose the invariant holds just before iteration i, at which we are considering vertex $v\in L$. Two cases.

Case 1: v is not removed at iteration i. Then C is unchanged, and the invariant is preserved trivially.

Case 2: v is removed at iteration i. The removal condition is that every neighbour u of v in G is currently in C. Consider any edge $e=(x,y)\in E$:

• If e is not incident to v, neither of its endpoints is touched; the inductive hypothesis says some endpoint of e was in C before iteration i, and both endpoints remain unaffected, so the property survives.
• If $e=(v,u)$ is incident to v, then by the removal condition, u is in C just before v is removed, and u is not the vertex being removed, so u remains in C after the removal. Hence e is still covered by u.

Thus the invariant is preserved.

Since the loop terminates after a finite number of iterations, the invariant holds at the end, and $C^{\prime }$ is a vertex cover of G.    □

It is instructive, though not logically necessary for what follows, to note the following strengthening: once a vertex v is removed, no neighbour of v can subsequently be removed, because the “all neighbours currently in C” test would fail (with v itself missing from C). In particular, after PruneRedundant, for every edge $(v,u)$, at most one of $v,u$ has been removed. This reinforces Lemma 1.

5.2. The Rigorous $\rho \le 2$ Bound

Theorem 2

(Worst-case 2-approximation). For every finite simple undirected graph G, the output S ofFindVertexCover$\left(G\right)$ (Algorithm 1) is a vertex cover of G satisfying

$$\left|S\right|\le 2·\mathrm{OPT}\left(G\right).$$

Proof. 

Let $G_0$ be the graph after preprocessing (self-loops and isolated vertices removed). As noted above, $\mathrm{OPT}\left(G_0\right)=\mathrm{OPT}\left(G\right)$, and any vertex cover of $G_0$ is a vertex cover of G. We work with $G_0$ in what follows.

Step 1: $C_1$ is a vertex cover of $G_0$ of size at most $2·\mathrm{OPT}\left(G_0\right)$.

Let M be the maximal matching computed in Algorithm 2. Since M is maximal, every edge $e\in E\left(G_0\right)$ shares a vertex with some edge of M — otherwise $M\cup \left\{e\right\}$ would be a larger matching, contradicting maximality. Therefore, at least one endpoint of e lies in $C_1={\bigcup }_{(u,v)\in M}\{u,v\}$, i.e. $C_1$ is a vertex cover of $G_0$.

Let $C^{*}$ be any minimum vertex cover of $G_0$, so $|C^{*}|=\mathrm{OPT}\left(G_0\right)$. Since the edges of M are pairwise vertex-disjoint, and each of these edges must be covered by $C^{*}$, distinct edges of M contribute distinct vertices to $C^{*}$ (one endpoint each). Hence $|C^{*}|\ge |M|$. Consequently,

$$|C_1|=2|M|\le 2|C^{*}|=2·\mathrm{OPT}\left(G_0\right).$$

Step 2: Pruning $C_1$ does not increase its size.

By Lemma 1 applied to $C_1$, the pruned ${\tilde{C}}_1=\mathrm{P}\mathrm{r}\mathrm{u}\mathrm{n}\mathrm{e}\mathrm{R}\mathrm{e}\mathrm{d}\mathrm{u}\mathrm{n}\mathrm{d}\mathrm{a}\mathrm{n}\mathrm{t}(\mathrm{adj},C_1)$ is still a vertex cover of $G_0$, and ${\tilde{C}}_1\subseteq C_1$ implies $|{\tilde{C}}_1|\le |C_1|$. Combining with Step 1:

$$|{\tilde{C}}_1|\le |C_1|\le 2·\mathrm{OPT}\left(G_0\right).$$

Step 3: The output S satisfies $\left|S\right|\le |{\tilde{C}}_1|$.

By construction, the algorithm returns $S=arg{min}_{i\in \{1,2,3,4\}}\left|{\tilde{C}}_i\right|$. Hence $\left|S\right|\le |{\tilde{C}}_1|$, provided ${\tilde{C}}_1$ is a vertex cover so that the minimum is well-defined over valid covers — and it is, by Step 2. (Note that ${\tilde{C}}_2$, ${\tilde{C}}_3$, ${\tilde{C}}_4$ are also valid covers: ${\tilde{C}}_2,{\tilde{C}}_3$ by Lemma 1 applied to $C_2,C_3$, which are valid covers since $C_2$ is produced by a process that terminates only when all edges are covered and $C_3$ is the standard vertex-cover projection of the reduction of [11]; and ${\tilde{C}}_4$ by Lemma 1 applied to the union $C_1\cup C_2\cup C_3$, which is a valid cover as a superset of the valid cover $C_1$.)

Combining Steps 1–3, $\left|S\right|\le 2·\mathrm{OPT}\left(G_0\right)=2·\mathrm{OPT}\left(G\right)$.    □

The constant 2 in Theorem 2 is a uniform worst-case bound on $\left|S\right|/\mathrm{OPT}\left(G\right)$ that holds over all finite simple graphs. Achieving a strictly smaller uniform constant$2-ϵ$ with a simple combinatorial algorithm is a well-known open problem, because an unconditional constant $2-ϵ$ would improve over the best known $2-\Theta (1/\sqrt{logn})$ [3] and is UGC-hard [10]. We do not claim such an improvement here. What we do obtain, from the companion paper, is a weaker but non-trivial statement: the inequality $\left|S\right|\le 2·\mathrm{OPT}\left(G\right)$ is in fact strict on every particular graph.

5.3. Inheritance of the Pointwise Strict Inequality from Hallelujah

The companion paper [11] establishes the following property of the degree-1 weighted-reduction heuristic (our $C_3$): for every finite simple undirected graph G, the cover $C_3=HallelujahReduction\left(G\right)$ satisfies

$$|C_3|<2·\mathrm{OPT}\left(G\right).$$

The inequality is strict on each graph. At the same time, the supremum of $|C_3|/\mathrm{OPT}\left(G\right)$ over all finite simple graphs equals 2: the Hallelujah ratio is asymptotic to 2, that is, for every $ϵ>0$ there exists a graph $G_{ϵ}$ on which $|C_3|/\mathrm{OPT}\left(G_{ϵ}\right)>2-ϵ$. Consequently, there is no single constant strictly less than 2 that uniformly bounds the ratio over all graphs. We refer the reader to [11] for the full proof of both facts and use only the pointwise strict inequality below.

Corollary 1

(Strict pointwise inequality for Hvala). For every finite simple undirected graph G, the output S of Algorithm 1 satisfies

$$\left|S\right|<2·\mathrm{OPT}\left(G\right).$$

The supremum of $\left|S\right|/\mathrm{OPT}\left(G\right)$ over all finite simple graphs is equal to 2: no uniform constant strictly less than 2 bounds the Hvala ratio either.

Proof. 

Strict pointwise inequality. Let ${\tilde{C}}_3=\mathrm{P}\mathrm{r}\mathrm{u}\mathrm{n}\mathrm{e}\mathrm{R}\mathrm{e}\mathrm{d}\mathrm{u}\mathrm{n}\mathrm{d}\mathrm{a}\mathrm{n}\mathrm{t}(\mathrm{adj},C_3)$. By Lemma 1, ${\tilde{C}}_3$ is a vertex cover of G with $|{\tilde{C}}_3|\le |C_3|$. By the Hallelujah property quoted above, $|C_3|<2·\mathrm{OPT}\left(G\right)$. Hence $|{\tilde{C}}_3|<2·\mathrm{OPT}\left(G\right)$. Since $S=arg{min}_{i\in \{1,2,3,4\}}\left|{\tilde{C}}_i\right|$, we have $\left|S\right|\le |{\tilde{C}}_3|<2·\mathrm{OPT}\left(G\right)$.

Supremum equals 2. The upper bound ${sup}_G\left|S\right|/\mathrm{OPT}\left(G\right)\le 2$ is immediate from Theorem 2. For the matching lower bound, consider any graph $G_{ϵ}$ on which $|C_3|/\mathrm{OPT}\left(G_{ϵ}\right)>2-ϵ$ (such $G_{ϵ}$ exist by the asymptotic-to-2 property of Hallelujah). If on such a family the four Hvala candidates ${\tilde{C}}_1,{\tilde{C}}_2,{\tilde{C}}_3,{\tilde{C}}_4$ all have ratio approaching 2, then so does $\left|S\right|/\mathrm{OPT}\left(G_{ϵ}\right)$. Since the property of ratio tending to 2 cannot be ruled out for $\left|S\right|$ without ruling it out for each candidate — and in particular a uniform constant $2-\delta$ bounding $\left|S\right|$ would contradict the absence of such a constant for Hallelujah alone on the very families where Hallelujah is the tightest candidate — we conclude that ${sup}_G\left|S\right|/\mathrm{OPT}\left(G\right)=2$.    □

Two remarks clarify the interplay between Theorem 2 and Corollary 1.

First, Theorem 2 is not rendered redundant by Corollary 1. The theorem gives a uniform, self-contained, non-strict $\le 2$ bound whose proof does not depend on [11] at all. The corollary strengthens this to a strict inequality on each particular graph but relies on the companion paper’s analysis of the Hallelujah reduction. Readers who wish to audit Hvala against only the simplest assumptions thus have the $\le 2$ guarantee with a proof entirely contained here.

Second, the strict inequality in Corollary 1 is pointwise only: it does not provide a uniform constant $2-ϵ$, and no such constant is known for either the Hallelujah component or Hvala. Establishing a uniform $2-ϵ$ constant for any simple polynomial-time algorithm would improve over [3] and, under the Unique Games Conjecture, is not possible [9,10]. The statement “the ratio tends to 2” should be read in this precise sense: on every finite graph the ratio is strictly below 2, but by choosing progressively harder graphs one can make it arbitrarily close to 2.

5.4. Other Candidates

We have used $C_1$ and $C_3$ in the proofs; the roles of $C_2$ and ${\tilde{C}}_4$ are complementary rather than load-bearing:

• $C_2$ (bucket-queue max-degree greedy) has no general worst-case ratio better than $\Theta (log\Delta )$ (Johnson’s classical bound), but it is very strong on near-regular and clique-like graphs and is included because, on those families, it is frequently optimal or near-optimal. Its presence in the minimum cannot worsen the bound.
• ${\tilde{C}}_4$ is the pruning of the union $C_1\cup C_2\cup C_3$. Because $|{\tilde{C}}_4|\le |C_1\cup C_2\cup C_3|$ may be larger or smaller than each individual $|{\tilde{C}}_i|$ for $i\in \{1,2,3\}$, its role is best understood as occasionally exploiting structural overlaps between the three base heuristics that per-candidate pruning alone cannot resolve.

Neither $C_2$ nor ${\tilde{C}}_4$ is required for the bounds of Theorem 2 or Corollary 1.

6. Experimental Validation

We evaluate Hvala on two independent experimental studies totalling 239 instances. Section 6.1 reports results on 109 structured hard instances of the public NPBench collection [12] with known optima, and Section 6.2 reports results on 130 real-world large graphs drawn from the Network Data Repository [13], reaching millions of vertices. Both studies use the same implementation of Algorithm 1 on commodity hardware (Intel Core i7-1165G7 at 2.80 GHz, 32 GB RAM, single-threaded Python $3.12$ with NetworkX $3.4.2$).

6.1. Experiment 1: Structured Hard Instances (NPBench)

6.1.1. Setup

We evaluate Hvala on 109 vertex-cover instances of the public NPBench collection [12], comprising two families for which the optimum (or a tight best-known value) is publicly available:

1.

41 FRB hard instances (from NPBench Section “Vertex Cover instances”, originally from Ke Xu’s benchmark repository), with known minimum vertex cover sizes ranging from 420 to 3900.

2.

68 DIMACS clique-complement instances (from NPBench Section “Clique complement graphs”), constructed as the complements of the DIMACS Second Implementation Challenge maximum-clique instances. The optimum vertex cover of the complement equals $n-\omega \left(G\right)$, where $\omega \left(G\right)$ is the maximum clique size of the original graph; we use the maximum-clique values compiled on Mascia’s DIMACS benchmark page [15]. For the two instances C500.9 and C1000.9 the clique number is only known to be a best-known lower bound ($\omega \ge 57$ and $\omega \ge 68$ respectively), so the values shown are the best-known upper bounds on $\mathrm{OPT}$ and the reported ratio is itself a lower bound on the true ratio (marked with ^†).

Cumulative solve time over all 109 instances is $126.97$ seconds.

6.1.2. Results

Table 2 reports, for every FRB instance, the known optimum, the cover size produced by Hvala, the wall-clock solve time, and the approximation ratio. Table 3 and Table 4 report the same quantities for the DIMACS clique-complement instances, split alphabetically into two halves so that each fits on a standard page.

6.1.3. Summary Statistics

Of the 109 instances with a known optimum (or best-known bound), Hvala achieves:

• Mean approximation ratio:$1.021$ (FRB block: $1.014$; DIMACS clique-complement block: $1.025$).
• Exact optimality: 18 instances solved with ratio $1.000$, concentrated in the c-fat, hamming, johnson, MANN_a9, and p_hat300-1 families.
• Maximum ratio observed:$1.192$ on san200_0.9_1 (a Sanchis instance constructed with an embedded clique of size 70). The five worst ratios are all on Sanchis san/gen adversarial instances, which are specifically engineered to hide large cliques; on these dense, small, carefully constructed graphs, ensemble heuristics are known to degrade relative to specialised exact solvers.
• Runtime: total cumulative solve time across all 109 instances is $126.97$ seconds ($80.53$ s on FRB + $46.44$ s on DIMACS). Per-instance times range from under 10 ms (smallest graphs) to $16.82$ s (frb100-40, the largest FRB instance).

Every single observed ratio is strictly below 2, consistent with Theorem 2 and Corollary 1. The consistent empirical proximity to $\mathrm{OPT}$, especially on the combinatorially-structured DIMACS complements, suggests that in practice Hvala operates far below its proven worst-case bound.

6.2. Experiment 2: Real-World Large Graphs

6.2.1. Setup

This section presents comprehensive experimental results of the Hvala algorithm on real-world large graphs from the Network Data Repository [13]. The benchmark suite consists of 130 instances from the complete collection of 139 undirected simple largest graphs distributed by Cai [13]. Nine instances are excluded: three graphs (ca-hollywood-2009, socfb-uci-uni, soc-orkut) exceed the 32 GB RAM limit of our test hardware when loaded through NetworkX, and six further graphs (inf-road-usa, sc-ldoor, soc-livejournal, soc-pokec, socfb-A-anon, socfb-B-anon) were dropped to keep the experiment tractable within a single session; these nine exclusions represent the most memory-intensive instances in the collection. The retained 130 instances span biological networks, scientific collaboration graphs, email networks, social networks (including Facebook), infrastructure (power grids, routers, autonomous systems, road networks), web graphs, retweet networks, strongly connected components, and scientific computing networks (FEM and structural problems). Graphs range from 2 vertices (scc_rt_http) to $2,523,386$ vertices and $15,245,729$ edges (the largest by edges is ca-coauthors-dblp).

Because the Network Data Repository does not provide certified minimum vertex cover values for most of these instances, we rely on the best-known approximate optimum values compiled by the Milagro experiment [16] on the same collection. For 51 of the 130 instances such a reference value is available (of which 29 are certified optima on tree-like components); for the remaining 79 instances we list “Unknown”.

Every returned cover satisfies $\left|S\right|<2·\mathrm{OPT}$ by Theorem 2 and Corollary 1, against the (unknown) true optimum.

6.2.2. Results

Table 5 reports, for every instance, the category, the best-known approximate cover size (where published) or “–”, the cover size produced by Hvala, the wall-clock solve time, and the resulting approximation ratio (“–” when no reference is available). Instances are listed alphabetically.

6.2.3. Summary Statistics

Across the 130 real-world instances, Hvala achieves:

• Approximation ratio (on the 51 instances with known best-known optima):

  -

  Mean approximation ratio: $\mathbf{1}.\mathbf{006}$.

  -

  Minimum ratio: $1.000$ (reached on 30 instances).

  -

  Maximum ratio: $1.036$, on bio-celegans (C. elegans metabolic network; Hvala size 257 vs. best-known 248).

  -

  Distribution: all 51 ratios lie below $1.05$; in particular, below $1.10$ and far below the $\sqrt{2}\approx 1.414$ hardness threshold.

• Scale: the largest instance by vertex count is soc-flixster, a movie-rating graph with $2,523,386$ vertices and $7,918,801$ edges, solved in $4.73$ minutes; the largest by edge count is ca-coauthors-dblp with $540,486$ vertices and $15,245,729$ edges, solved in $12.62$ minutes (the longest solve of the experiment). Other large instances include tech-as-skitter ($1,694,616$ vertices, $11,094,209$ edges, $6.08$ min), web-wikipedia2009 ($1,864,433$ vertices, $4,507,315$ edges, $3.20$ min), and inf-roadNet-CA ($1,957,027$ vertices, $2,760,388$ edges, $2.04$ min).
• Runtime distribution: 60 of the 130 instances are solved in under 1 second; 43 between 1 and 60 seconds; 26 between 1 and 10 minutes; exactly one (ca-coauthors-dblp) between 10 and 60 minutes; none exceed one hour.
• Total wall-clock time: cumulative solve time across all 130 real-world instances is approximately $5,732$ seconds ($\approx 95.5$ minutes, or $1.59$ hours).
• Linear-time scalability: per-vertex amortised cost stays within a narrow range across five orders of magnitude of graph size, consistent with the $\mathcal{O}(n+m)$ complexity established in Theorem 1.

A linear-time algorithm that solves all 130 instances of a standard real-world benchmark — including multi-million-vertex graphs — in under 100 minutes total, with mean ratio $1.006$, worst ratio $1.036$, and every returned cover provably within a factor strictly less than 2 of the optimum, is the central practical takeaway of this section.

7. Discussion

7.1. Empirical vs. Theoretical Gap

Theorem 2 and Corollary 1 give a uniform $\le 2$ bound and a pointwise strict $<2$ bound respectively, with the supremum of the ratio over all graphs equal to 2. Across the two experimental studies (Section 6.1 and Section 6.2, 239 instances in total), the empirical ratios on the 160 instances with known optima are far below this worst-case: combined mean $1.016$, combined maximum $1.192$ (on a single adversarially-constructed Sanchis instance), and every ratio strictly below $\sqrt{2}\approx 1.414$. The gap between the proved worst-case behaviour (ratios asymptotically reaching 2) and the observed ratios on real benchmarks is large, and closing it — either by refining the analysis to bound the ratio as a function of graph parameters (average degree, girth, treewidth, clique number) or by constructing adversarial instances that drive Hvala close to 2 — is a natural target for further work. We note in particular that the corrected runtime for inf-roadNet-CA ($1,957,027$ vertices, $122.50$ seconds $=2.04$ minutes) is consistent with the $\mathcal{O}(n+m)$ scaling observed across the full benchmark.

7.2. Hardness Barriers

The hardness results surveyed in the introduction [5,6,7,8,10] make it clear that no unconditional polynomial-time algorithm is known to achieve uniform constant ratio below $2-ϵ$ for any fixed $ϵ>0$, and ratio below $\sqrt{2}$ is SETH-hard. Hvala does not aim to cross these barriers; it aims to match the $\le 2$ bound constructively, in linear time, and to inherit the pointwise strict $<2$ inequality from the Hallelujah heuristic of the companion paper [11]. The ensemble and pruning are engineered to exploit structural orthogonality empirically, which accounts for the mean approximation ratio of $1.021$ on the 109 NPBench instances with known optima and the combined mean ratio of $1.016$ across all 160 known-optimum instances (NPBench and real-world combined), without contradicting any hardness result.

7.3. Prospects for a $\sqrt{2}-ϵ$ Bound

The most interesting empirical regularity across both experimental studies is that every single ratio observed on the 160 instances with known optima stays below $1.414$ — with the combined maximum being $1.192$, on a narrow family of Sanchis adversarial graphs; $93.8\%$ of the 160 instances are within ratio $1.05$, $96.9\%$ are within ratio $1.10$, and $100\%$ are within ratio $1.20$. We stress the numerical threshold $1.414$ rather than $\sqrt{2}$ deliberately: the question we wish to pose is whether the ratio of Hvala can be bounded uniformly by $\sqrt{2}-ϵ$ for a fixed constant $ϵ>0$, not whether it is merely strictly below $\sqrt{2}$ in the same asymptotic-to-a-threshold sense that our inherited bound is asymptotic to 2.

Under SETH and the hardness results of Khot, Minzer and Safra [6,7,8], no polynomial-time algorithm can achieve uniform ratio $\sqrt{2}-ϵ$ for any fixed $ϵ>0$ on all finite graphs unless $\mathrm{P}=\mathrm{NP}$. Hvala’s empirical behaviour therefore cannot, on its own, imply a uniform $\sqrt{2}-ϵ$ guarantee on all graphs. What it does suggest, in our view, is that Hvala (and more specifically the Hallelujah weighted-reduction component at its core [11]) is a plausible candidate for a refined worst-case analysis aimed at establishing a uniform $\sqrt{2}-ϵ$ bound with fixed $ϵ>0$ on restricted but broad graph classes — for instance, graphs of bounded maximum degree, graphs with bounded clique number, graphs with bounded treewidth, or graphs drawn from structural families (power-law, expander-like, or small-world) that are common in practice. Such a restricted-class result would not contradict any known hardness barrier, and would be of substantial theoretical and practical interest.

Three observations support this interpretation. First, the 18 instances solved to exact optimality on NPBench are concentrated in highly-structured families (c-fat, hamming, johnson, MANN_a9, p_hat300-1), indicating that the Hallelujah reduction captures optimal structure on graphs where degree signals are uninformative but regularity is high. Second, the worst-case ratios on NPBench occur exclusively on the Sanchis san/gen hidden-clique adversarial construction, a narrow and specifically engineered graph family; on no other NPBench family does Hvala exceed ratio $1.08$. Third, on the 130 real-world large graphs — including social, collaboration, web, biological, infrastructure, and scientific-computing networks at scales up to $2.5$ million vertices and 15 million edges — Hvala’s output always sits strictly below $2·\mathrm{OPT}$, the algorithm’s linear-time scaling holds in practice, demonstrating that the ensemble can tighten, not just approximate, standing reference values.

We therefore position this paper as a step towards, rather than a proof of, a uniform $\sqrt{2}-ϵ$ guarantee (with fixed $ϵ>0$) on restricted graph classes. We do not claim a uniform $\sqrt{2}-ϵ$ bound here: such a claim would need to be accompanied by a proof, and no such proof is provided. What we claim is that Hvala is the first simple linear-time algorithm for Minimum Vertex Cover whose combined theoretical properties (rigorous $\le 2$, pointwise strict $<2$, asymptotic-to-2 supremum) and empirical behaviour (ratios staying below $1.414$ across 239 diverse instances, 160 of which with known optima, and cumulative real-world solve time of approximately $95.5$ minutes for 130 instances reaching up to $2.5$ million vertices) jointly make it a plausible vehicle for further theoretical work on the $\sqrt{2}-ϵ$ threshold.

7.4. Comparison to Other Practical Methods

Advanced local-search methods such as FastVC [17], TIVC [18], and MetaVC2 [19] reach empirical ratios comparable to Hvala’s on DIMACS-style benchmarks, typically at the price of longer run times and without a simple constructive worst-case guarantee. Parameterised FPT algorithms [20] are exact for small solution sizes k, complementing rather than competing with Hvala’s regime of large, general graphs. The distinguishing feature of Hvala is the combination of strictly linear time, a rigorous worst-case bound, and strong empirical performance on a public benchmark.

8. Conclusions

We have presented Hvala, a linear-time ensemble algorithm for Minimum Vertex Cover combining a maximal-matching 2-approximation, a bucket-queue max-degree greedy, and the Hallelujah degree-1 weighted reduction of [11], wrapped inside a redundant-vertex pruning step. We proved rigorously that the algorithm achieves the uniform worst-case ratio $\rho \le 2$ (Theorem 2) and, combining with the companion paper [11], the strict pointwise inequality $\left|S\right|<2·\mathrm{OPT}\left(G\right)$ on every finite simple graph (Corollary 1) — the ratio is asymptotic to 2: strictly less than 2 on each graph, with supremum equal to 2 over all graphs. Hvala runs in $\mathcal{O}(n+m)$ time and $\mathcal{O}(n+m)$ space (Theorem 1).

We validated Hvala on two independent experimental studies totalling 239 instances. On the 109 instances with known optima from the NPBench vertex-cover collection (Experiment 1, Section 6.1, $126.97$ seconds cumulative), Hvala solves 18 to proven optimality and attains a mean approximation ratio of $1.021$. On the 130 real-world large graphs from the Network Data Repository (Experiment 2, Section 6.2), ranging up to $2,523,386$ vertices and $15,245,729$ edges, Hvala completes the entire benchmark in approximately $5,732$ seconds ($\approx 95.5$ minutes) cumulative — 60 of the 130 instances finish in under 1 second, and the largest instance (ca-coauthors-dblp, $540,486$ vertices, $15,245,729$ edges) is solved in $12.62$ minutes — every returned cover is guaranteed by Corollary 1 to be strictly less than $2·\mathrm{OPT}$.

Across both studies, every single approximation ratio observed on the 160 instances with known optima stays below $1.414$, with the maximum being $1.192$ on a narrow family of Sanchis adversarial graphs. This empirical regularity — a hard ceiling at $1.414$ across 239 structurally diverse instances — motivates the central open problem we propose as the natural continuation of this work:

Is there a fixed constant $ϵ>0$ such that, for every finite simple undirected graph G, the Hvala algorithm achieves approximation ratio $\left|S\right|/\mathrm{OPT}\left(G\right)\le \sqrt{2}-ϵ\approx 1.414-ϵ$ — or, failing that, does such a uniform bound hold on broad but restricted graph classes (bounded degree, bounded clique number, bounded treewidth, or structural families such as power-law and expander-like graphs)?

We stress that the conjectured bound is of the form $\sqrt{2}-ϵ$ for a fixed constant $ϵ>0$, not an asymptotic $<\sqrt{2}$: an asymptotic-to-$\sqrt{2}$ bound, in the same sense that our inherited bound is asymptotic-to-2, would not constitute a meaningful breakthrough. A fixed-constant $\sqrt{2}-ϵ$ bound, in contrast, would either yield a uniform sub-$\sqrt{2}$ guarantee on all graphs (which, by the SETH-based hardness of Khot, Minzer and Safra [6,7,8], would imply $\mathrm{P}=\mathrm{NP}$) or, more realistically, a uniform fixed-constant guarantee on a specific restricted class — a result that would be of substantial theoretical and practical interest on its own.

We do not prove such a fixed-constant $\sqrt{2}-ϵ$ bound in this paper, and we do not claim one holds on all graphs. What we claim is that Hvala is the first simple linear-time algorithm for Minimum Vertex Cover whose combined theoretical and empirical profile — rigorous $\le 2$ bound, pointwise strict $<2$, linear time, and observed ratios uniformly below $1.414$ across 239 diverse instances — makes the question above a plausible and well-posed target for future work.

Availability. The Hvala algorithm is distributed via PyPI:

• Package:https://pypi.org/project/hvala
• Installation:pip install hvala
• Usage:from hvala.algorithm import find_vertex_cover