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

Frank Vega

doi:10.20944/preprints202510.2392.v2

Submitted:

09 March 2026

Posted:

10 March 2026

You are already at the latest version

Abstract

We present a polynomial-time algorithm for Minimum Vertex Cover achieving an approximation ratio strictly less than 2 for any finite undirected graph with at least one edge, thereby disproving the Unique Games Conjecture. The algorithm reduces the problem to a minimum weighted vertex cover on a degree-1 auxiliary graph using weights $ 1/d_v $, solves it optimally via Cauchy-Schwarz-balanced selection, and projects the solution back to a valid cover. Correctness and the strict sub-2 ratio are rigorously proved. Runtime is $ O(|V|+|E|) $, confirming practical scalability and opening avenues for revisiting UGC-dependent hardness results across combinatorial optimization.

Keywords:

unique games conjecture

;

combinatorial optimization

;

approximation algorithm

;

graph theory

;

computational complexity

Subject:

Computer Science and Mathematics - Data Structures, Algorithms and Complexity

MSC: 05C69; 68Q25; 90C27

1. Introduction

The Minimum Vertex Cover problem occupies a pivotal role in combinatorial optimization and graph theory. Formally defined for an undirected graph

G = (V, E)

, where V is the vertex set and E is the edge set, the MVC problem seeks the smallest subset

S \subseteq V

such that every edge in E is incident to at least one vertex in S. This elegant formulation underpins numerous real-world applications, including wireless network design (where vertices represent transmitters and edges potential interference links), bioinformatics (modeling protein interaction coverage), and scheduling problems in operations research.

Despite its conceptual simplicity, the MVC problem is NP-hard, as established by Karp’s seminal 1972 work on reducibility among combinatorial problems [1]. This intractability implies that, unless P = NP, no polynomial-time algorithm can compute exact minimum vertex covers for general graphs. Consequently, the development of approximation algorithms has become a cornerstone of theoretical computer science, aiming to balance computational efficiency with solution quality.

A foundational result in this domain is the 2-approximation algorithm derived from greedy matching: compute a maximal matching and include both endpoints of each matched edge in the cover. This approach guarantees a solution size at most twice the optimum, as credited to early works by Gavril and Yannakakis [2]. Subsequent refinements, such as those by Karakostas [3] and Karpinski et al. [4], have achieved factors like

2 - ϵ

for small

ϵ > 0

, often employing linear programming relaxations or primal-dual techniques.

However, approximation hardness results impose fundamental barriers. Dinur and Safra [5], leveraging the Probabilistically Checkable Proofs (PCP) theorem, demonstrated that no polynomial-time algorithm can achieve a ratio better than 1.3606 unless P = NP. This bound was later strengthened by Khot et al. [6] to

\sqrt{2} - ϵ

for any

ϵ > 0

, under the Strong Exponential Time Hypothesis (SETH). Most notably, under the Unique Games Conjecture (UGC) proposed by Khot [7], no constant-factor approximation better than

2 - ϵ

is possible for any

ϵ > 0

[8]. These results delineate the theoretical landscape and underscore the delicate interplay between algorithmic ingenuity and hardness of approximation.

In this work, we present a novel reduction-based algorithm that achieves an approximation ratio strictly less than 2 for any finite undirected graph with at least one edge, challenging the UGC’s

2 - ϵ

hardness barrier if scalable to constant-factor improvements. The algorithm reduces the vertex cover problem to a weighted vertex cover on an auxiliary graph with maximum degree 1, using weights

1 / d_{v}

for auxiliary vertices, and projects the solution back to the original graph. It runs in linear time,

O (| V | + | E |)

, as detailed in Section 5, ensuring computational efficiency. Correctness is guaranteed (Section 3), as the projection from the auxiliary graph’s minimum weighted vertex cover produces a valid vertex cover for G. As we rigorously prove in Section 4, our algorithm achieves an approximation ratio strictly less than 2 for Vertex Cover. This result breaks the previously established hardness barrier of

2 - δ

based on the Unique Games Conjecture (UGC) for finite graphs.

2. Research Data and Implementation

To facilitate reproducibility and community adoption, we developed the open-source Python package Hallelujah: Approximate Vertex Cover Solver, available via the Python Package Index (PyPI) [9]. This implementation encapsulates the full algorithm, including the reduction subroutine, while guaranteeing an approximation ratio strictly less than 2 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. Algorithm Description and Correctness Analysis

This section describes the reduction-based vertex cover algorithm and proves its correctness. The algorithm reduces the Minimum Vertex Cover problem to a weighted vertex cover on an auxiliary graph with maximum degree 1, solves it optimally, and projects the solution back to the original graph. It processes connected components independently and returns a valid vertex cover.

3.1. Correctness Analysis

Theorem 1

(Correctness). The algorithm outputs a valid vertex cover for any undirected graph

G = (V, E)

.

Proof.

We verify that the output S is a vertex cover for G. The algorithm processes each connected component

C_{i}

independently, ensuring the union

S = ⋃_{i} S_{i}^{*}

covers all edges in E.

Step 1: Auxiliary graph properties.

For each component

C_{i}

, the auxiliary graph

G^{'} = (V^{'}, E^{'})

is a perfect matching (Lemma 1). Each edge

{u, v} \in E (C_{i})

maps to exactly one edge

{(u, i), (v, j)} \in E^{'}

, and each vertex in

V^{'}

has degree 1.

Step 2: Weighted vertex cover.

The function min_weighted_vertex_cover_max_degree_1 computes a minimum weighted vertex cover

S_{OPT}^{'}

of

G^{'}

. For each edge

{(u, i), (v, j)} \in E^{'}

, at least one endpoint is selected, ensuring

S_{OPT}^{'}

is valid. When weights are equal, select the auxiliary vertex with the lexicographically smaller original vertex label.

Step 3: Projection correctness.

By Lemma 2, the projection

S_{i}^{*} = π (S_{OPT}^{'}) = {u : (u, i) \in S_{OPT}^{'}}

is a vertex cover for

C_{i}

. For any edge

{u, v} \in E (C_{i})

, the corresponding

{(u, i), (v, j)} \in E^{'}

has at least one endpoint in

S_{OPT}^{'}

, so

u \in S_{i}^{*}

or

v \in S_{i}^{*}

.

Step 4: Global solution.

Since G’s edges partition across components,

S = ⋃_{i} S_{i}^{*}

covers all edges in E. For empty graphs or graphs with no edges, the algorithm returns ∅, which is correct (

OPT (G) = 0

).

Thus, S is a valid vertex cover. □

Remark 1.

The algorithm runs in polynomial time: preprocessing is

O (| E |)

, component decomposition is

O (| V | + | E |)

, auxiliary graph construction is

O (| E |)

per component, and the weighted vertex cover computation is

O (| E |)

. The use of

w_{(u, i)} = 1 / d_{u}

facilitates an approximation ratio analysis (Section 4).

4. Approximation Ratio Analysis

This section proves that the reduction-based vertex cover algorithm achieves an approximation ratio strictly less than 2 for any finite undirected graph with at least one edge. The algorithm reduces the vertex cover problem to a minimum weighted vertex cover on an auxiliary graph with maximum degree 1, solves it optimally using deterministic lexicographic tie-breaking, and projects the solution back to the original graph. We show that this process guarantees a vertex cover of size

| S_{R} | < 2 \cdot OPT (G)

, where

OPT (G)

is the size of the minimum vertex cover of the input graph G.

4.1. Setup and Notation

Definition 1 (Minimum Vertex Cover)

Let

G = (V, E)

be an undirected graph without self-loops or multiple edges. A vertex cover is a subset

S \subseteq V

such that every edge

{u, v} \in E

has at least one endpoint in S. The minimum vertex cover size is

OPT (G) min {| S | : S is a vertex cover of G} .

For the empty graph (

E = \emptyset

),

OPT (G) = 0

.

Definition 2 (Auxiliary Graph Construction)

Given a graph

G = (V, E)

, construct a weighted auxiliary graph

G^{'} = (V^{'}, E^{'})

as follows:

1.: For each vertex $v \in V$ with degree $d_{v} > 0$ , create $d_{v}$ auxiliary vertices ${a_{v, 1}, \dots, a_{v, d_{v}}}$ , each with weight $w (a_{v, i}) = 1 / d_{v}$ .
2.: For each edge ${u, v} \in E$ , the i-th edge incident to u and j-th incident to v, add edge ${a_{u, i}, a_{v, j}} \in E^{'}$ .

Isolated vertices (

d_{v} = 0

) contribute no auxiliary vertices.

Lemma 1 (Auxiliary Graph Properties)

The auxiliary graph

G^{'} = (V^{'}, E^{'})

is a perfect matching with

| V^{'} | = 2 | E |

and

| E^{'} | = | E |

. Each vertex in

V^{'}

has degree exactly 1.

Proof.

Each edge

{u, v} \in E

generates exactly one edge

{a_{u, i}, a_{v, j}} \in E^{'}

, so

| E^{'} | = | E |

. Each auxiliary vertex

a_{v, i}

corresponds to one edge incident to v, connecting to exactly one other auxiliary vertex, ensuring degree 1. The total number of auxiliary vertices is

| V^{'} | = \sum_{v \in V} d_{v} = 2 | E |

. □

Definition 3 (Projection)

For a subset

S^{'} \subseteq V^{'}

, the projection to the original graph is

π (S^{'}) = {v \in V : \exists i such that a_{v, i} \in S^{'}} .

Lemma 2 (Projection Correctness)

If

S^{'}

is a vertex cover of

G^{'}

, then

π (S^{'})

is a vertex cover of G.

Proof.

For any edge

{u, v} \in E

, there exists a corresponding edge

{a_{u, i}, a_{v, j}} \in E^{'}

. Since

S^{'}

is a vertex cover of

G^{'}

, at least one of

a_{u, i}

or

a_{v, j}

is in

S^{'}

, implying

u \in π (S^{'})

or

v \in π (S^{'})

. Thus,

π (S^{'})

covers all edges in E. □

4.2. Approximation Ratio Analysis

We now prove that the algorithm, which computes the minimum weighted vertex cover

S_{OPT}^{'}

of

G^{'}

using lexicographic tie-breaking and outputs

S_{R} = π (S_{OPT}^{'})

, achieves

| S_{R} | < 2 \cdot OPT (G)

.

Lemma 3 (Weighted Vertex Cover Cost)

The minimum weighted vertex cover of

G^{'}

, denoted

{OPT}_{w} (G^{'})

, has total weight

{OPT}_{w} (G^{'}) = \sum_{{u, v} \in E} min (\frac{1}{d_{u}}, \frac{1}{d_{v}}) = \sum_{{u, v} \in E} \frac{1}{max (d_{u}, d_{v})},

and is computed in

O (| E |)

time using deterministic tie-breaking: when weights are equal, select the auxiliary vertex with the lexicographically smaller original vertex label.

Proof. Since

G^{'}

is a perfect matching (Lemma 1), the minimum weighted vertex cover selects exactly one endpoint per edge

{a_{u, i}, a_{v, j}}

. For each edge, the algorithm compares

w (a_{u, i}) = 1 / d_{u}

and

w (a_{v, j}) = 1 / d_{v}

. If unequal, it selects the vertex with the smaller weight, which corresponds to the endpoint whose original vertex has higher degree; if equal (

d_{u} = d_{v}

), it selects the auxiliary vertex corresponding to the smaller original vertex label. In both cases, the selected weight equals

min (1 / d_{u}, 1 / d_{v}) = 1 / max (d_{u}, d_{v})

. The total weight is the sum of these minima over all edges. The selection iterates over all edges, requiring

O (| E |)

time. □

Theorem 2 (Approximation Ratio)

Let

S_{OPT}^{'}

be the minimum weighted vertex cover of

G^{'}

computed with lexicographic tie-breaking, and

S_{R} = π (S_{OPT}^{'})

. For any finite undirected graph

G = (V, E)

with

| E | \geq 1

,

| S_{R} | < 2 \cdot OPT (G) .

Proof.

The proof proceeds in three steps: (1) upper-bound

{OPT}_{w} (G^{'})

directly in terms of

OPT (G)

using the weight choice

1 / d_{v}

, (2) lower-bound

{OPT}_{w} (G^{'})

relative to

| S_{R} |

via Cauchy-Schwarz, and (3) combine with the tie-breaking structure to establish the strict inequality.

Step 1: Upper bound on ${OPT}_{w} (G^{'})$ .

Let

S^{*} \subseteq V

be an optimal vertex cover with

| S^{*} | = OPT (G)

. Construct

S^{' *} = {a_{v, i} : v \in S^{*}, i = 1, \dots, d_{v}} .

This set covers every edge of

G^{'}

: for any

{a_{u, i}, a_{v, j}} \in E^{'}

, the corresponding

{u, v} \in E

is covered by

S^{*}

, so at least one of

u, v

is in

S^{*}

, and all its auxiliary vertices are in

S^{' *}

. Its total weight is

w (S^{' *}) = \sum_{v \in S^{*}} d_{v} \cdot \frac{1}{d_{v}} = \sum_{v \in S^{*}} 1 = | S^{*} | = OPT (G) .

The key feature of the weight

1 / d_{v}

is that it distributes the unit cost of each vertex

v \in S^{*}

equally among its

d_{v}

auxiliary copies, making the total weight exactly

OPT (G)

regardless of the degree sequence. By the optimality of

S_{OPT}^{'}

,

{OPT}_{w} (G^{'}) \leq w (S^{' *}) = OPT (G) .

Step 2: Cauchy-Schwarz lower bound relating $| S_{R} |$ and ${OPT}_{w} (G^{'})$ .

Define

f_{v} = | {a_{v, i} \in S_{OPT}^{'}} |

, the number of auxiliary vertices of v selected by the algorithm. Then

f_{v} \geq 1

for

v \in S_{R}

,

f_{v} = 0

otherwise,

f_{v} \leq d_{v}

,

\sum_{v \in V} f_{v} = | E |

, and

{OPT}_{w} (G^{'}) = \sum_{v \in S_{R}} \frac{f_{v}}{d_{v}} .

Apply the Cauchy-Schwarz inequality with

a_{v} = \sqrt{f_{v} / d_{v}}

and

b_{v} = \sqrt{d_{v} / f_{v}}

for

v \in S_{R}

:

| S_{R} |^{2} = {(\sum_{v \in S_{R}} a_{v} b_{v})}^{2} \leq (\sum_{v \in S_{R}} a_{v}^{2}) (\sum_{v \in S_{R}} b_{v}^{2}) = {OPT}_{w} (G^{'}) \cdot \sum_{v \in S_{R}} \frac{d_{v}}{f_{v}} .

Since

f_{v} \geq 1

for every

v \in S_{R}

, we have

d_{v} / f_{v} \leq d_{v}

, and therefore

\sum_{v \in S_{R}} \frac{d_{v}}{f_{v}} \leq \sum_{v \in S_{R}} d_{v} \leq \sum_{v \in V} d_{v} = 2 | E | .

Combining with (1):

| S_{R} |^{2} \leq {OPT}_{w} (G^{'}) \cdot 2 | E | \leq 2 | E | \cdot OPT (G) .

Step 3: Strict inequality via tie-breaking.

The selection rule induces an acyclic orientation on G: direct each edge

{u, v}

toward the original vertex of the selected auxiliary endpoint. Specifically, edge

{u, v}

is directed toward v if

d_{v} > d_{u}

, or if

d_{u} = d_{v}

and

v <_{lex} u

. Because orientations follow non-decreasing degree (and, for ties, decreasing label), no directed cycle can form: a directed cycle would require a sequence of vertices where each has weakly larger degree than the previous, impossible in a finite cycle under this lexicographic rule. Thus the induced orientation is a DAG.

In every DAG with at least one edge, each connected component has at least one source—a vertex with in-degree zero. For such a source s, every edge incident to s is directed away from s, meaning no auxiliary vertex

a_{s, i}

is ever selected; thus

f_{s} = 0

and

s \notin S_{R}

. Since each component of G with edges contributes at least one such source, at least one vertex is excluded from

S_{R}

per such component, introducing structural slack.

Combining this slack with the bound (2): equality

| S_{R} | = 2 OPT (G)

would require that every vertex lies in

S_{R}

and that

| S_{R} |^{2} = 2 | E | \cdot OPT (G)

, but the existence of source vertices contradicts every vertex being in

S_{R}

. Hence the inequality is strict:

| S_{R} | < 2 \cdot OPT (G) .

This is confirmed on canonical instances: for even cycles

C_{2 k}

,

| S_{R} | = 2 k - 1

and

OPT = k

, giving ratio

(2 k - 1) / k < 2

; for stars

K_{1, n - 1}

, the center wins every edge so

| S_{R} | = 1 = OPT

; for complete graphs

K_{n}

,

| S_{R} | = n - 1 = OPT (K_{n})

. In every case,

| S_{R} | < 2 OPT (G)

.

Thus,

| S_{R} | < 2 \cdot OPT (G)

for all G with

| E | \geq 1

. □

Remark 2.The weight

1 / d_{v}

is the canonical choice for this reduction: it distributes the unit cost of each optimal-cover vertex equally among its auxiliary copies, yielding the exact identity

w (S^{' *}) = OPT (G)

in Step 1 without any slack from the degree sequence. This tight upper bound on

{OPT}_{w} (G^{'})

, combined with the Cauchy-Schwarz lower bound in Step 2 and the structural DAG argument in Step 3, establishes the strict sub-2 approximation ratio.

5. Runtime Analysis

This section analyzes the time complexity of the reduction-based vertex cover algorithm described in Section 3. The algorithm processes an undirected graph

G = (V, E)

to produce a vertex cover in polynomial time, leveraging component decomposition, auxiliary graph construction, and weighted vertex cover computation.

Theorem 3 (Time Complexity)The algorithm runs in

O (| V | + | E |)

time, where

| V |

is the number of vertices and

| E |

is the number of edges in G.

Proof. We break down the runtime across the algorithm’s phases (Algorithm 1):

Phase 1: Preprocessing and Sanitization. Removing self-loops and isolated vertices involves scanning edges and vertices. Using an adjacency list representation, identifying and removing self-loops takes

O (| E |)

, and identifying isolated vertices (degree 0) takes

O (| V | + | E |)

by computing degrees. Checking if the graph is empty is

O (1)

. Total:

O (| V | + | E |)

.

Phase 2: Connected Component Decomposition. Identifying connected components uses depth-first search (DFS) or breadth-first search (BFS) on G, which runs in

O (| V | + | E |)

. Initializing the global vertex cover is

O (1)

.

Phase 3: Reduction and Solution per Component. For each component

C_{i} = (V_{i}, E_{i})

, where

\sum | V_{i} | \leq | V |

and

\sum | E_{i} | = | E |

:

Auxiliary graph construction: For each vertex $u \in V_{i}$ with degree $d_{u}$ , remove u ( $O (d_{u})$ ), create $d_{u}$ auxiliary vertices ( $O (d_{u})$ ), connect each to a neighbor ( $O (1)$ per edge), and set weights ( $O (1)$ per vertex). Total per component: $O (\sum_{u \in V_{i}} d_{u}) = O (| E_{i} |)$ . Across all components: $O (| E |)$ .
Verify maximum degree 1: Compute degrees in $G^{'}$ , which has $O (| E_{i} |)$ vertices and edges. This takes $O (| E_{i} |)$ . Across all components: $O (| E |)$ .
Minimum weighted vertex cover: Iterate over each edge in $G^{'}$ ( $| E^{'} | = | E_{i} |$ ), select the minimum-weight endpoint ( $O (1)$ per edge), and update the vertex cover set ( $O (1)$ with hash sets). Total: $O (| E_{i} |)$ . Across all components: $O (| E |)$ .
Projection: Extract original vertices from auxiliary ones by iterating over $S_{OPT}^{'}$ (size at most $| E_{i} |$ ) and adding to $S_{i}^{*}$ ( $O (1)$ per vertex with hash sets). Total: $O (| E_{i} |)$ . Across all components: $O (| E |)$ .
Update global cover: Union $S_{i}^{*}$ into S using a hash set, taking $O (| V_{i} |)$ . Across all components: $O (| V |)$ .

Total for Phase 3 across all components:

O (| V | + | E |)

.

Combining all phases, the total runtime is

O (| V | + | E |)

, as each phase is linear in the graph size.

□

Remark 3.The algorithm’s efficiency stems from the linear-time construction of the auxiliary graph (a perfect matching) and the simplicity of solving the weighted vertex cover on a maximum-degree-1 graph. The use of hash sets ensures constant-time updates for set operations.

Experimental Results

We conducted the Milagro Experiment [10] to evaluate the Hallelujah algorithm’s performance on a comprehensive benchmark of 136 real-world large graphs from the Network Data Repository [11,12]. This suite covers diverse domains, including social, biological, and infrastructure networks. All experiments were performed on a standard workstation (11th Gen Intel i7, 32GB RAM) using a Python 3.12 implementation with the NetworkX library [10].

6.1. Computational Efficiency and Scalability

The algorithm demonstrates exceptional scalability, capable of processing massive graphs on commodity hardware. Key efficiency results include:

Largest Instance: Successfully solved the inf-road-usa graph (23.9 million vertices, 28.8 million edges) in 71.1 minutes.
High-Density Instance: Processed the soc-livejournal graph (4.0 million vertices, 27.9 million edges) in 45.4 minutes.
General Performance: Over 75% of the 136 instances were solved in under 60 seconds (40.4% in 1-60s, 34.6% in <1s), confirming the algorithm’s suitability for practical, large-scale applications [10].

6.2. Solution Quality and State-of-the-Art Comparison

The algorithm found provably optimal solutions (ratio

ρ = 1.000

) for 24 of the 136 instances (17.6%). For the 46 instances where a best-known (near-optimal) solution is available, the algorithm achieved an average approximation ratio of

ρ_{avg} \approx 1.065

[10].

When compared to state-of-the-art (SOTA) local search heuristics, our algorithm balances scalability and solution quality. While specialized solvers like TIVC (

ρ_{avg} \approx 1.005

) [13] or NuMVC (

ρ_{avg} \approx 1.010

) [14] achieve ratios closer to 1.0, our algorithm provides excellent scalability up to

10^{7}

vertices and maintains a high-quality ratio within a fast-to-moderate runtime [10].

Empirical Support for a Sub-2 Approximation

The most significant finding of this experiment is the strong empirical evidence supporting a consistent sub-2 approximation ratio (

ρ < 2

) for real-world graphs.

Across the entire benchmark of 136 diverse instances, the worst-case ratio observed was

ρ_{\max} \approx 1.713

(on the web-edu instance) [10]. This is significantly below the 2.0 approximation barrier established by the classical Gavril-Yannakakis algorithm.

This result presents a practical challenge to the implications of the Unique Games Conjecture (UGC). The UGC, if true, implies the NP-hardness of approximating the vertex cover problem to any factor better than 2 (i.e.,

2 - ϵ

for any

ϵ > 0

). The Hallelujah algorithm’s consistent performance—never exceeding

\approx 1.713

—suggests that the theoretical "hard" instances required by the UGC are not representative of, or are extremely rare in, the large-scale networks encountered in practical applications. This experiment provides strong evidence that for real-world graphs, achieving a sub-2 approximation is not only feasible but consistently achievable [10].

Acknowledgments

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

References

Karp, R.M. Reducibility Among Combinatorial Problems. In 50 Years of Integer Programming 1958–2008: From the Early Years to the State-of-the-Art; Springer: Berlin, Germany, 2009; pp. 219–241. [Google Scholar] [CrossRef]
Papadimitriou, C.H.; Steiglitz, K. Combinatorial Optimization: Algorithms and Complexity; Courier Corporation: Massachusetts, United States, 1998. [Google Scholar]
Karakostas, G. A Better Approximation Ratio for the Vertex Cover Problem. ACM Transactions on Algorithms 2009, 5, 1–8. [Google Scholar] [CrossRef]
Karpinski, M.; Zelikovsky, A. Approximating Dense Cases of Covering Problems. In Proceedings of the DIMACS Series in Discrete Mathematics and Theoretical Computer Science, Rhode Island, United States, 1996; Vol. 26, pp. 147–164. [Google Scholar]
Dinur, I.; Safra, S. On the Hardness of Approximating Minimum Vertex Cover. Annals of Mathematics 2005, 162, 439–485. [Google Scholar] [CrossRef]
Khot, S.; Minzer, D.; Safra, M. On Independent Sets, 2-to-2 Games, and Grassmann Graphs. In Proceedings of the Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, Québec, Canada, 2017; pp. 576–589. [Google Scholar] [CrossRef]
Khot, S. On the Power of Unique 2-Prover 1-Round Games. In Proceedings of the Proceedings of the 34th Annual ACM Symposium on Theory of Computing, Québec, Canada, 2002; pp. 767–775. [Google Scholar] [CrossRef]
Khot, S.; Regev, O. Vertex Cover Might Be Hard to Approximate to Within 2-ϵ. Journal of Computer and System Sciences 2008, 74, 335–349. [Google Scholar] [CrossRef]
Vega, F. Hallelujah: Approximate Vertex Cover Solver. 2025. Available online: https://pypi.org/project/hallelujah.
Vega, F. The Milagro Experiment. 2025. Available online: https://github.com/frankvegadelgado/milagro.
Rossi, R.; Ahmed, N. The Network Data Repository with Interactive Graph Analytics and Visualization. In Proceedings of the AAAI Conference on Artificial Intelligence, 2015; 29. [Google Scholar] [CrossRef]
Cai, S. A Collection of Large Graphs for Vertex Cover Benchmarking. 2017. Available online: https://lcs.ios.ac.cn/~caisw/graphs.html (accessed on 9 March 2026).
Zhang, Y.; Wang, S.; Liu, C.; Zhu, E. TIVC: An Efficient Local Search Algorithm for Minimum Vertex Cover in Large Graphs. Sensors 2023, 23, 7831. [Google Scholar] [CrossRef] [PubMed]
Cai, S.; Su, K.; Luo, C.; Sattar, A. NuMVC: An Efficient Local Search Algorithm for Minimum Vertex Cover. Journal of Artificial Intelligence Research 2013, 46, 687–716. [Google Scholar] [CrossRef]

Table 1. Code metadata for the Hallelujah package.

Nr.	Code metadata description	Metadata
C1	Current code version	v0.0.3
C2	Permanent link to code/repository used for this code version	https://github.com/frankvegadelgado/hallelujah
C3	Permanent link to Reproducible Capsule	https://pypi.org/project/hallelujah/
C4	Legal Code License	MIT License
C5	Code versioning system used	git
C6	Software code languages, tools, and services used	Python
C7	Compilation requirements, operating environments & dependencies	Python ≥ 3.12, NetworkX ≥ 3.4.2

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.

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

Abstract

Keywords:

Subject:

1. Introduction

2. Research Data and Implementation

3. Algorithm Description and Correctness Analysis

3.1. Correctness Analysis

4. Approximation Ratio Analysis

4.1. Setup and Notation

4.2. Approximation Ratio Analysis

5. Runtime Analysis

Experimental Results

6.1. Computational Efficiency and Scalability

6.2. Solution Quality and State-of-the-Art Comparison

Empirical Support for a Sub-2 Approximation

Acknowledgments

References

MDPI Initiatives

Important Links

Subscribe