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

1. Introduction

The Minimum Vertex Cover (VC) problem is one of the twenty-one NP-complete problems identified by Karp [1]. Given an undirected graph $G=(V,E)$, a set $C\subseteq V$ is a vertex cover if every edge of E has at least one endpoint in C; the goal is to find a minimum-cardinality vertex cover, denoted $\tau \left(G\right)$. Vertex cover is central to computer science, modelling guard placement, network monitoring, error-correcting codes, and serving as the canonical starting point for parameterised and approximation algorithms.

The approximation landscape for VC is unusually well charted. The classical maximal-matching algorithm achieves a 2-approximation in linear time [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 falls short of a constant $2-\epsilon$. From the hardness side, Dinur and Safra [5] ruled out any ratio below $10\sqrt{5}-21\approx 1.3606$ under $\mathrm{P}\ne \mathrm{NP}$, and Khot, Minzer, and Safra [6,7,8], proving the 2-to-2 games conjecture, raised this unconditional barrier to $\sqrt{2}-\epsilon$ for every fixed $\epsilon >0$ under $\mathrm{P}\ne \mathrm{NP}$. Under the Unique Games Conjecture [9], Khot and Regev [10] showed that no polynomial-time algorithm can approximate Minimum Vertex Cover within factor $2-\epsilon$ for any fixed $\epsilon >0$. Thus a proved constant ratio strictly below $\sqrt{2}$ for a polynomial-time algorithm would imply $\mathrm{P}=\mathrm{NP}$, and a proved constant ratio strictly below 2 would refute the Unique Games Conjecture under $\mathrm{P}\ne \mathrm{NP}$.

Against this backdrop, we present an algorithm—implemented as the Salvador Python package (v0.0.9)—that produces a vertex cover whose size is provably never more than twice the optimum and, on every instance we have tested under the default call $\epsilon =1$, far closer to it. The algorithm, called FindVertexCover, is an ensemble: it computes nine independently valid candidate covers and returns the smallest. Four of the candidates and the pruning pass adapt the ensemble published as the Hvala algorithm [11,12], which proves an unconditional $O(n+m)$ time and space bound and worst-case approximation ratio at most 2; Salvador therefore contains Hvala. Salvador adds five candidates of its own, described below. The algorithm operates in four phases.

1.

Preprocessing. Self-loops are discarded; isolated vertices are removed (they appear in no edge and need not be covered).

2.

Ensemble of linear-time candidates. Seven independent heuristics are run on the cleaned graph G: maximal matching, bucket-queue maximum-degree greedy, and a degree-1 weighted-reduction ("Hallelujah") heuristic (all three adapted from Hvala [11]; the Hallelujah resolution is made selection-aware in this version); a Min-to-Min bucket heuristic and a primal-dual/local-ratio 2-approximation; SolveVC, which reduces G to a weighted MIDS instance on a planar forest-core gadget and solves it with a Baker-style pass [13] of layering width $k=\lceil 1/\epsilon \rceil$ (at the default $\epsilon =1$, $k=1$ and the pass is its linear-time greedy baseline); and BipartitePlanarCover, the oriented-incidence reduction to a bipartite planar auxiliary graph, solved exactly by a linear-time cycle dynamic program.

3.

Linear-time pruning.PruneRedundantVertices (Hvala’s fourth strategy) removes from each candidate every vertex all of whose neighbours are already in the cover; it is applied to every candidate and to their union.

4.

Budgeted local search.LocalSearchCover takes the smallest pruned candidate and improves its complementary independent set by $(1,2)$-swaps and perturbations, stopping after $O(n+m)$ adjacency scans; it never returns a larger cover than its input. The smallest of the nine resulting covers is returned.

At the default $\epsilon =1$ every one of the nine candidates runs in worst-case $O(n+m)$ time, where $n=\left|V\right|$ and $m=\left|E\right|$, so the whole ensemble is $O(n+m)$. This holds in particular for the Min-to-Min heuristic, whose bucket-queue argument pops and processes one minimum-degree vertex per step, for the bipartite planar reduction, whose auxiliary graph is solved exactly by a linear-time dynamic program (Lemma 1), and for the local search, whose work is capped by an explicit $O(n+m)$ budget.

Contributions

The main contributions of this paper are:

• A linear-time ensemble vertex-cover algorithm with nine candidates, four of which adapt the published Hvala ensemble [11], so that Salvador contains Hvala and inherits its guarantees.
• A structural lemma (Lemma 1) showing that the oriented-incidence auxiliary graph of the bipartite planar reduction is a disjoint union of even cycles and single edges, so its exact minimum-weight vertex cover takes $O(n+m)$ time; and a residual, minimum-degree-ordered variant of the reduction that improves its covers further.
• A selection-aware resolution rule for the Hallelujah heuristic that removes its redundancy on graphs whose vertices share one degree, and a budgeted $(1,2)$-swap iterated local search that never worsens the ensemble’s best cover.
• An unconditional worst-case approximation ratio of at most 2 for every graph (Theorem 2).
• A reproducible suite of $1,746$ graphs on which the exact or certified ratio never exceeds $1.17$, using certified lower bounds (exact bipartite matching, Karp–Sipser matching, clique packing and a Laplacian Hoffman bound) that are much sharper than the maximal-matching bound used before, together with a per-family report of which candidate wins.
• Two conjectures with conditional consequences: a universal ratio below 2 would refute UGC under $\mathrm{P}\ne \mathrm{NP}$ (Theorem 4), and a universal ratio of at most $7/5=\sqrt{2}-{\epsilon }_0$ would imply $\mathrm{P}=\mathrm{NP}$ (Theorem 5).
• A head-to-head comparison with Hvala on the 68 DIMACS clique-complement instances of NPBench (Section 7.3), on which Salvador never returns a larger cover and returns a strictly smaller one on 48 instances.
• An open-source implementation, Salvador v0.0.9.

The paper is organised as follows. Section 3 describes the algorithm and provides pseudocode. Section 4 proves correctness. Section 5 analyses the approximation ratio and discusses conditional consequences for the Unique Games Conjecture and for $\mathrm{P}$ versus $\mathrm{NP}$. Section 6 establishes the time complexity. Section 7 reports empirical results on a reproducible test suite. Section 8 concludes.

2. Research Data

The algorithm is implemented in the Python package Salvador, freely available on the Python Package Index [14]. The current version is v0.0.9; the accuracy parameter $\epsilon$ drives only the Baker-PTAS candidate’s layering (Remark 2), not the ensemble’s linear-time guarantee, which holds at the default $\epsilon =1$ regardless. Code metadata is summarised in Table 1, the local reduction gadget of the SolveVC candidate is depicted in Figure 1, and the oriented-incidence gadget of the bipartite planar reduction in Figure 2.

3. Description of the Algorithm

Salvador’s entry point, FindVertexCover (Algorithm 1), is an ensemble. It computes seven independently valid candidate covers by seven different linear-time heuristics ($c_1,\dots ,c_6$ and $c_8$), prunes each with PruneRedundantVertices, prunes their union to form $c_7$, improves the smallest of these eight with a budgeted local search to form $c_9$, and returns the smallest of the nine. Four of the candidate heuristics—maximal matching ($c_1$), bucket-queue maximum-degree greedy ($c_2$), the degree-1 weighted-reduction heuristic ($c_3$), and the pruning pass itself—adapt the ensemble published as the Hvala algorithm [11,12], which proves that they run in $O(n+m)$ time and space and that the best of them already achieves worst-case approximation ratio at most 2. Salvador adds the Min-to-Min heuristic ($c_4$), a primal-dual/local-ratio 2-approximation ($c_5$), the planar forest-core MIDS reduction SolveVC ($c_6$), the bipartite planar oriented-incidence reduction BipartitePlanarCover ($c_8$), and the local search LocalSearchCover ($c_9$). We present pseudocode for the main ensemble, the candidates, and the pruning pass.

3.1. Main Ensemble

Algorithm 1: FindVertexCover$(G,\epsilon )$

Require:  Undirected graph $G=(V,E)$, accuracy parameter $\epsilon \in (0,1]$ (default $\epsilon =1$; only $c_6$ depends on $\epsilon$, and at $\epsilon =1$ every candidate runs in $O(n+m)$ time, see Remark 2) Ensure:  A vertex cover $C\subseteq V$ 1: Remove all self-loops from G 2: $G\leftarrow G\setminus \{v\in V:{deg}_G\left(v\right)=0\}$▹ isolated vertices are in no edge 3: if$E=\varnothing$thenreturn∅ 4: end if 5: $\mathit{adj}\leftarrow \{v\mapsto N_G\left(v\right):v\in V\}$ 6: $c_1\leftarrow MaximalMatchingCover\left(G\right)$▹ Hvala strategy 1 7: $c_2\leftarrow BucketDegreeGreedy\left(\mathit{adj}\right)$▹ Hvala strategy 2 8: $c_3\leftarrow ReductionMaxDegreeOne\left(G\right)$▹ Hvala strategy 3, "Hallelujah", selection-aware 9: $c_4\leftarrow MinToMinCover\left(\mathit{adj}\right)$▹ Salvador-specific 10: $c_5\leftarrow LinearWeightedCover\left(G\right)$▹ Salvador-specific, primal-dual 11: $c_6\leftarrow SolveVC(G,\epsilon )$▹ Salvador-specific, planar MIDS reduction 12: for$i\in \{1,\dots ,6\}$do 13:     $c_i\leftarrow PruneRedundantVertices(\mathit{adj},c_i)$▹ Hvala strategy 4, applied to every candidate 14: end for 15: $c_8\leftarrow BipartitePlanarCover\left(\mathit{adj}\right)$▹ Salvador-specific, Alg. 7; already pruned 16: $c_7\leftarrow PruneRedundantVertices(\mathit{adj},c_1\cup \dots \cup c_6\cup c_8)$ 17: $c^{★}\leftarrow arg{min}_{i\in \{1,\dots ,8\}}\left|c_i\right|$ 18: $c_9\leftarrow LocalSearchCover(\mathit{adj},c^{★})$▹ Salvador-specific, Alg. 9; $|c_9|\le |c^{★}|$ 19: return$arg{min}_{i\in \{1,\dots ,9\}}\left|c_i\right|$

3.2. The Hvala-Adapted Candidates

Candidates $c_1$, $c_2$, and $c_3$, and the pruning pass shared by the candidates, adapt the ensemble of Vega’s Hvala algorithm [11], which proves an unconditional $O(n+m)$ time and space bound and worst-case approximation ratio at most 2 for every graph. $MaximalMatchingCover\left(G\right)$ (Hvala strategy 1) computes a maximal matching in $O(n+m)$ time and returns both endpoints of every matched edge; this is the classical linear-time 2-approximation [2]. $BucketDegreeGreedy\left(\mathit{adj}\right)$ (Hvala strategy 2, given as Algorithm 2) repeatedly removes a maximum-degree active vertex using a bucket queue indexed by degree, in $O(n+m)$ amortized time; its worst-case approximation ratio is $\Theta (log\Delta )$ by Johnson’s classical bound [2], where $\Delta$ is the maximum degree. $ReductionMaxDegreeOne\left(G\right)$ (Hvala strategy 3, the "Hallelujah heuristic") replaces every vertex u of degree d by d auxiliary copies of weight $1/d$, one per incident edge, so that the auxiliary instance is a perfect matching with one auxiliary edge per original edge; it chooses one endpoint of each auxiliary edge and maps the choice back to G, in $O(n+m)$ time.

Selection-aware resolution of the Hallelujah heuristic.

Earlier versions resolved each auxiliary edge independently, by weight and then by a label tie-break. When all vertices share one degree, every weight $1/d$ ties, so the cover was decided by labels alone and could contain almost every vertex ($n-1$ vertices on the n-cycle, 251 of 256 on the 8-cube). Version 0.0.9 scans the original vertices in ascending order of degree (bucket sort) and resolves the auxiliary edges at u by three rules in priority order: (1) if either endpoint’s original vertex is already selected, the edge is covered and nothing is added; (2) otherwise the endpoint of strictly smaller weight (the higher-degree vertex) is selected, and if that is u the scan of u stops; (3) on a tie, the neighbour of u is selected. Every auxiliary edge is inspected at most twice, so the running time stays $O(n+m)$. Before pruning, the candidate drops from 98 to 50 vertices on $C_{100}$ and from 397 to 200 on the $20\times 20$ torus, both optimal.

Algorithm 2:BucketDegreeGreedy$\left(\mathit{adj}\right)$ — Hvala strategy 2

Require: Adjacency map $\mathit{adj}$ of a graph with maximum degree $\Delta$ Ensure: A vertex cover $C\subseteq V$ 1: $deg\left(v\right)\leftarrow \left|\mathit{adj}\right(v\left)\right|$ for every v; place every v in bucket queue $B_{deg\left(v\right)}$ 2: $C\leftarrow \varnothing$; $\mathit{removed}\leftarrow \varnothing$ 3: for$d\leftarrow \Delta$downto 1 do 4:     while $B_d$ is non-empty do 5:         $v\leftarrow$ pop from $B_d$ 6:         if $v\in \mathit{removed}$or current $deg\left(v\right)\ne d$or$deg\left(v\right)=0$ then continue 7:         end if 8:         $C\leftarrow C\cup \left\{v\right\}$; $\mathit{removed}\leftarrow \mathit{removed}\cup \left\{v\right\}$ 9:         for $u\in \mathit{adj}\left(v\right)$ with $u\notin \mathit{removed}$ do 10:            $deg\left(u\right)\leftarrow deg\left(u\right)-1$; push u onto $B_{deg\left(u\right)}$▹ stale copies are skipped on pop, above 11:         end for 12:     end while 13: end for 14: returnC

3.3. The Salvador-Specific Candidates

$LinearWeightedCover\left(G\right)$ ($c_5$) is a single $O(n+m)$ pass implementing the primal-dual/local-ratio method [15]: it scans every edge once, raises a dual variable at each endpoint up to the remaining slack, and adds an endpoint to the cover whenever its budget saturates; this is a standard 2-approximation.

$MinToMinCover\left(\mathit{adj}\right)$ ($c_4$), given as Algorithm 3, repeatedly pops a single currently-minimum-degree active vertex v from a bucket queue and adds an arbitrary current neighbor of v to the cover, then updates degree buckets exactly as in Algorithm 2.

Remark 1

(Why the bucket-queue argument stays linear). Algorithm 3 pops and processes exactly one minimum-degree vertex per outer-loop iteration and selects its covering neighbor in $O\left(1\right)$ (an arbitrary, not degree-minimal, neighbor), with no rescan of a bucket at any step. Consequently the total number of bucket pushes and pops is $O(n+m)$ by the same amortized argument as Algorithm 2 (Theorem 6), and the time per processed vertex stays within a constant factor regardless of graph regularity.

Algorithm 3:MinToMinCover$\left(\mathit{adj}\right)$ — linear-time-corrected

Require:  Adjacency map $\mathit{adj}$ Ensure:  A vertex cover $C\subseteq V$ 1: $deg\left(v\right)\leftarrow \left|\mathit{adj}\right(v\left)\right|$ for every v; place every v with $deg\left(v\right)>0$ in bucket queue $B_{deg\left(v\right)}$ 2: $C\leftarrow \varnothing$; $\mathit{min}\_\mathit{d}\leftarrow 1$ 3: while$\mathit{min}\_\mathit{d}\le \Delta$do 4:     advance $\mathit{min}\_\mathit{d}$ to the smallest index with a non-empty bucket; if none, break 5:     $v\leftarrow$ pop from $B_{\mathit{min}\_\mathit{d}}$ 6:     if current $deg\left(v\right)\ne \mathit{min}\_\mathit{d}$or$deg\left(v\right)=0$thencontinue▹ stale entry, O(1) skip 7:     end if 8:     $\mathit{target}\leftarrow$ an arbitrary element of $\mathit{adj}\left(v\right)$▹$O\left(1\right)$: no rescan of the bucket 9:     $C\leftarrow C\cup \left\{\mathit{target}\right\}$ 10:     for $u\in \mathit{adj}\left(\mathit{target}\right)$do▹ standard degree-bucket removal, as in Alg. 2 11:         $deg\left(u\right)\leftarrow deg\left(u\right)-1$; push u onto $B_{deg\left(u\right)}$ if $deg\left(u\right)>0$ 12:     end for 13:     remove $\mathit{target}$ from the active graph 14:     if $deg\left(v\right)>0$then push v onto $B_{deg\left(v\right)}$▹v lost its edge to $\mathit{target}$ 15:     end if 16:     if $\mathit{min}\_\mathit{d}>1$and$B_{\mathit{min}\_\mathit{d}-1}$ non-empty then$\mathit{min}\_\mathit{d}\leftarrow \mathit{min}\_\mathit{d}-1$ 17:     end if 18: end while 19: returnC

3.4. Weighted MIDS Gadget and Planar Solve

Algorithm 4 ($c_6$) implements the reduction from Vertex Cover to weighted Minimum Independent Dominating Set on a planar core, invokes the $\epsilon$-controlled Baker PTAS pass, and repairs non-core edges in one scan.

Algorithm 4:SolveVC$(G,\epsilon )$

Require:  Planar or non-planar graph $G=(V,E)$, parameter $\epsilon$ Ensure:  A vertex cover $C\subseteq V$ of G 1: $G_p,\mathit{removed}\leftarrow SpanningForestCore\left(G\right)$▹ Union-Find; $G_p$ is planar 2: $N\leftarrow \left|V\right(G_p\left)\right|$;   $P\leftarrow N+1$▹ hub penalty 3: $H\leftarrow \mathrm{new}\mathrm{graph}$ 4: for$v\in V\left(G_p\right)$do 5:     Add nodes $(v,0)$ with weight 1 and $(v,1)$ with weight 0 to H 6:     Add edge $\left\{\right(v,0),(v,1\left)\right\}$ to H 7: end for 8: for$(u,v)\in E\left(G_p\right)$do 9:     Add hub node $h_{uv}$ with weight P to H 10:     Add edges $\{(u,0),h_{uv}\}$ and $\{(v,0),h_{uv}\}$ to H 11: end for 12: $S\leftarrow BakerPtasWeightedIDS(H,\epsilon )$▹$\epsilon$-controlled PTAS on the forest gadget H 13: $C\leftarrow \{v\in V\left(G_p\right):(v,0)\in S\}$▹ decode cover (near-minimum core cover) 14: for$(u,v)\in E\left(G_p\right)$ with $u\notin C$ and $v\notin C$do▹ repair core edges 15:     $C\leftarrow C\cup \{arg{max}_{w\in \{u,v\}}{deg}_G\left(w\right)\}$ 16: end for 17: for$(u,v)\in \mathit{removed}$ with $u\notin C$ and $v\notin C$do▹ repair non-core edges 18:     $C\leftarrow C\cup \{arg{max}_{w\in \{u,v\}}{deg}_G\left(w\right)\}$ 19: end for 20: returnC

The pass BakerPtasWeightedIDS (Algorithm 5) is the accuracy-controlled weighted-IDS solver invoked by Salvador. It layers the gadget by BFS distance, removes each residue class modulo $k=\lceil 1/\epsilon \rceil$ in turn, solves the remaining components exactly by tree-decomposition dynamic programming, greedily repairs the removed slab, and keeps the lightest independent dominating set found over the k shifts; the greedy maximal independent set of Algorithm 6 is the $k=1$ baseline and a safe fallback. Because the gadget H built from a forest core is itself a forest (Section 3), each component is a tree and the per-component solve ExactWeightedIDS is an exact linear-time tree dynamic program; which shifts the PTAS explores, however, depends on $\epsilon$, so the decoded cover is parameter-sensitive and need not be monotone in $\epsilon$.

Remark 2

(On the accuracy parameter $\epsilon$). The public entry pointfind_vertex_coverfixes the default $\epsilon =1$, which is the configuration analysed throughout this paper. The parameter controls only candidate $c_6$’s Baker layering width $k=\lceil 1/\epsilon \rceil$; at the default $\epsilon =1$, $k=1$ and $c_6$ reduces to the greedy maximal-independent-set baseline of Algorithm 6, which is what keeps $c_6$—and hence the whole ensemble—strictly $O(n+m)$ (Theorem 6). The gadget construction is itself ε-independent; ε enters only the IDS pass. Passing $\epsilon <1$ makes only $c_6$ more thorough (and costs $c_6$ an extra $O(1/\epsilon )$ factor); it is intended for offline quality experiments on $c_6$ in isolation, not the default production call. $c_6$’s returned candidate depends on ε through the layer choices, and on the vertex ordering through the spanning-forest construction; the ensemble as a whole is comparatively insensitive to both, since $c_1,\dots ,c_5$ provide independent coverage (Section 5.7). All claims below refer to the default call $\epsilon =1$ unless otherwise noted.

Algorithm 5:BakerPtasWeightedIDS$(H,\epsilon )$

Require:  Weighted gadget H, accuracy $\epsilon \in (0,1]$ Ensure:  An independent dominating set $S\subseteq V\left(H\right)$ 1: $k\leftarrow max\{1,\lceil 1/\epsilon \rceil \}$ 2: if$k=1$thenreturnGreedyWeightedMIS$\left(H\right)$ 3: end if▹ cheap baseline 4: $\ell \leftarrow$ BFS-distance layering of H 5: $S^{★}\leftarrow GreedyWeightedMIS\left(H\right)$;   $\mathit{best}\leftarrow w\left(S^{★}\right)$ 6: for$i\leftarrow 0$to$k-1$do 7:     $R\leftarrow \{v:\ell (v)\equiv i(modk\left)\right\}$▹ removed slab 8:     $S_i\leftarrow \varnothing$ 9:     for each connected component K of $H\left[V\right(H)\setminus R]$ do 10:         $S_i\leftarrow S_i\cup ExactWeightedIDS\left(K\right)$▹ tree-decomposition DP 11:     end for 12:     greedily add the cheapest still-undominated vertices of R to $S_i$ 13:     if $S_i$ is a valid IDS and$w\left(S_i\right)<\mathit{best}$ then 14:         $S^{★}\leftarrow S_i$;   $\mathit{best}\leftarrow w\left(S_i\right)$ 15:     end if 16: end for 17: return$S^{★}$

Algorithm 6:GreedyWeightedMIS$\left(H\right)$ — $k=1$ baseline

Require:  Weighted gadget H with vertex weights $w(·)\in \{0,1,P\}$ Ensure:  A maximal (hence independent dominating) set $S\subseteq V\left(H\right)$ 1: Partition $V\left(H\right)$ into buckets $B_0,B_1,B_{\ge 2}$ by weight 0, 1, and P 2: Let the processing order be $B_0$, then $B_1$, then $B_{\ge 2}$ 3: $S\leftarrow \varnothing$;   $X\leftarrow \varnothing$▹X is the excluded set 4: forv in processing order do 5:     if $v\notin X$ then 6:         $S\leftarrow S\cup \left\{v\right\}$;   $X\leftarrow X\cup \left\{v\right\}\cup N_H\left(v\right)$ 7:     end if 8: end for 9: returnS

Figure 1 shows the local gadget introduced for each core edge $(u,v)\in E\left(G_p\right)$ in Algorithm 4. The nodes $(u,0)$ and $(v,0)$ are the weight-one cover-choice nodes, $(u,1)$ and $(v,1)$ are zero-weight pendant nodes, and the hub $h_{uv}$ has penalty weight $P=N+1$.

As illustrated in Figure 1, the gadget H is always planar because $G_p$ is a forest and H is a subdivision of $G_p$ augmented with pendant leaves $(v,1)$; subdivisions of planar graphs are planar, and appending pendant leaves preserves planarity. The hub weight $P=N+1$ enforces coverage inside the core: in any optimal MIDS for H, including a hub is more expensive than selecting all vertex nodes. The SpanningForestCore routine builds $G_p$ by Union-Find in one pass over E and records each cycle-closing edge in $\mathit{removed}$ for the final repair scan.

3.5. Bipartite Planar Oriented-Incidence Reduction

Candidate $c_8$ revisits the reduction of an earlier version of this work, in which every connected component is mapped to a weighted bipartite planar auxiliary graph B whose minimum-weight vertex cover is decoded into a cover of G. Vertices are processed in a fixed order; when u is processed, every edge $\{u,v_j\}$ ($j=1,\dots ,d$) to a not-yet-processed neighbour creates two oriented-incidence nodes $x_{u{v}_j}$ and $x_{v_{j}u}$, of weights $1/{deg}_G\left(u\right)$ and $1/{deg}_G\left(v_j\right)$, joined by a forcing edge; consecutive incidences are joined by local edges$\{x_{u{v}_j},x_{v_{j-1}u}\}$, closed by $\{x_{u{v}_1},x_{v_{d}u}\}$ when $d\ge 2$. A cover S of B is decoded to $\{u:x_{uv}\in S\}$. Figure 2 shows the gadget of one vertex.

Lemma 1

(Structure of the auxiliary graph). For every graph G and every processing order, B is a vertex-disjoint union of even cycles $C_{2d}$ (one for each processed vertex u with $d\ge 2$ unprocessed neighbours at its turn) and single edges $K_2$ (for $d=1$). In particular B is bipartite and planar, and $\left|V\right(B\left)\right|=2m$.

Proof. 

Each original edge $\{u,v\}$ is handled exactly once, when the first of its endpoints, say u, is processed: afterwards u is processed, so the edge is never handled again from v. Hence the two nodes $x_{uv},x_{vu}$ created for it are distinct from all others and occur only in the gadget of u, which gives $\left|V\right(B\left)\right|=2m$ and makes the gadgets of different vertices vertex-disjoint. Inside the gadget of u the edges are the forcing edges $\{x_{u{v}_j},x_{v_{j}u}\}$, the local edges $\{x_{v_{j-1}u},x_{u{v}_j}\}$ for $j=2,\dots ,d$, and the closing edge $\{x_{v_{d}u},x_{u{v}_1}\}$, which together form the closed walk $x_{u{v}_1},x_{v_{1}u},x_{u{v}_2},x_{v_{2}u},\dots ,x_{u{v}_d},x_{v_{d}u},x_{u{v}_1}$ through $2d$ distinct nodes: a cycle $C_{2d}$ for $d\ge 2$ and a single forcing edge for $d=1$. Even cycles and single edges are bipartite and planar, and so is their disjoint union.    □

Lemma 1 shows that the bipartiteness and planarity checks of the earlier reduction always succeed, and, more importantly, that the minimum-weight vertex cover of B needs no flow computation: on a path, a dynamic program over “node included / excluded” states computes an optimum in time linear in its length, and a cycle reduces to two paths by fixing whether its first node is in the cover. Summed over all gadgets this is $O\left(\right|V\left(B\right)\left|\right)=O\left(m\right)$, and it returns an optimal minimum-weight vertex cover of B. We verified this equality against an integer-programming solver on 150 random graphs and three processing orders; with the manuscript’s processing order the linear-time version reproduces 35 of the 43 cover sizes logged for the earlier implementation on the DIMACS clique complements and is smaller on 6 of the remaining 8 (the differences come from ties among optimal auxiliary covers and from the pruning order).

Residual variant.

Because B is solved exactly gadget by gadget, the processing order and the weights are free design choices. The residual variant always gives the next gadget to a vertex of minimum residual degree (degree in the subgraph of still-uncovered edges), weights the gadget by residual degrees, and deletes decoded vertices from the residual graph. Since u has minimum residual degree d, every neighbour has residual degree at least d, so the neighbour side of the cycle weighs ${\sum }_{j}1/d_{\mathrm{res}}\left(v_j\right)\le d·(1/d)=1$, which is the weight of the u side; with ties broken toward the neighbours, the exact cycle solve selects the neighbour side. The decoded cover is therefore the complement of a greedy minimum-degree maximal independent set, computed in $O(n+m)$ with a degree-indexed bucket queue in which every residual edge deletion lowers the bucket pointer by at most one. Candidate $c_8$ evaluates the manuscript-order and residual variants, prunes both, and keeps the smaller (Algorithm 7). On the 43 DIMACS clique complements the mean ratio is $1.042$ for the manuscript order and $1.027$ for the residual variant.

Algorithm 7:BipartitePlanarCover$\left(\mathit{adj}\right)$

Require: Adjacency map $\mathit{adj}$ of G Ensure: A vertex cover $c_8\subseteq V$ 1: $P\leftarrow \varnothing$;   $C_a\leftarrow \varnothing$▹ processed vertices; manuscript-order cover 2: for$u\in V$ in input order do 3:     $P\leftarrow P\cup \left\{u\right\}$;   $(v_1,\dots ,v_d)\leftarrow$ neighbours of u not in P 4:     if $d=0$ then continue 5:     end if 6:     $w\leftarrow (1/degu,1/deg{v}_1,1/degu,1/deg{v}_2,\dots ,1/degu,1/deg{v}_d)$▹ weights of $x_{u{v}_1},x_{v_{1}u},\dots$ 7:     $S\leftarrow MinWeightCycleCover\left(w\right)$▹ exact, $O\left(d\right)$; a single edge when $d=1$ 8:     add u to $C_a$ if some $x_{u{v}_j}\in S$; add every $v_j$ with $x_{v_{j}u}\in S$ 9: end for 10: $C_b\leftarrow$ residual variant (minimum residual degree order, residual weights, bucket queue) 11: return the smaller of $PruneRedundantVertices(\mathit{adj},C_a)$ and $PruneRedundantVertices(\mathit{adj},C_b)$

3.6. Linear-Time Pruning

Algorithm 8 removes redundant vertices from a candidate cover in a single forward pass, running in $O(n+m)$ total time.

Algorithm 8:PruneRedundantVertices$(\mathit{adj},C)$

Require:  Adjacency map $\mathit{adj}$, candidate cover $C\subseteq V$ Ensure:  Valid vertex cover $C^{\prime }\subseteq C$ after one forward redundancy-removal pass 1: $C^{\prime }\leftarrow \mathrm{mutable}\mathrm{copy}\mathrm{of}C$ 2: $L\leftarrow$ fixed snapshot of the elements of $C^{\prime }$▹ Python iterates list(cover) 3: for$v\in L$(in snapshot order) do 4:     if $N_G\left(v\right)\subseteq C^{\prime }$then▹ test against the current (shrinking) set $C^{\prime }$ 5:         $C^{\prime }\leftarrow C^{\prime }\setminus \left\{v\right\}$ 6:     end if 7: end for 8: return$C^{\prime }$

3.7. Budgeted Local Search

A vertex cover C is the complement of an independent set $S=V\setminus C$, so every vertex added to S is a vertex removed from C. Candidate $c_9$ improves the best of $c_1,\dots ,c_8$ through its complementary independent set with the $(1,2)$-swap neighbourhood of Andrade, Resende, and Werneck [16]. For $v\notin S$ let $\mathrm{tight}\left(v\right)=\left|N\right(v)\cap S|$. A $(1,2)$-swap removes a vertex $x\in S$ and inserts two non-adjacent neighbours $v,w$ of x with $\mathrm{tight}\left(v\right)=\mathrm{tight}\left(w\right)=1$, enlarging S by one; vertices left with $\mathrm{tight}=0$ are inserted as well. An iterated local search step forces a non-solution vertex into S, evicts its solution neighbours, re-inserts freed vertices, and runs swaps around the change; the step is kept if $\left|S\right|$ does not decrease and is undone through an undo log otherwise.

The swap test at x costs $O(degx+{\sum }_{v}degv)$ over its 1-tight neighbours v: when looking for a partner w of v, the scan of the 1-tight list stops at the first non-neighbour of v, so it never costs more than $degv+1$. Every primitive is charged its exact scan cost, and the search stops once the work exceeds $b(n+m)$, so Algorithm 9 runs in $O(n+m)$ time for the fixed constant b. The live set S is always the best seen, since worsening steps are undone, so $|c_9|\le |c^{★}|$.

Algorithm 9:LocalSearchCover$(\mathit{adj},C)$

Require:  Adjacency map $\mathit{adj}$, a vertex cover C, budget constant b (default $b=100$) Ensure:  A vertex cover $C^{\prime }$ with $|C^{\prime }|\le |C|$ 1: $S\leftarrow V\setminus C$; insert every vertex with $\mathrm{tight}=0$▹S maximal 2: $\mathit{limit}\leftarrow$ (work so far) $+b(n+m)$▹ work counter charges every adjacency scan 3: apply $(1,2)$-swaps at every $x\in S$, re-queueing inserted vertices, while work $\le \mathit{limit}$ 4: while work $\le \mathit{limit}$ do 5:     pick a pseudo-random $u\notin S$ (fixed seed); evict $N\left(u\right)\cap S$; insert u and freed vertices 6:     apply $(1,2)$-swaps around the change 7:     if $\left|S\right|$ decreased then undo the step via the undo log 8:     end if 9: end while 10: return$V\setminus S$

4. Correctness of the Algorithm

Theorem 1.

Algorithm 1 always returns a valid vertex cover of the input graph G.

Proof. 

We must show that every edge $(u,v)\in E$ has at least one endpoint in the output C. Isolated vertices are removed in preprocessing and appear in no edge, so they need not be covered. It suffices to show (a) each of $c_1,\dots ,c_6$ and $c_8$ is individually a valid vertex cover of the cleaned graph, (b) pruning a valid cover with Algorithm 8 leaves it valid, (c) the union of valid covers is a valid cover, and (d) $c_9$ is valid, since the output is then $argmin$ over the sizes of nine vertex sets each shown valid, and validity does not depend on which has minimum size.

(a) Each raw candidate is valid.$c_1$ takes both endpoints of every matched edge of a maximal matching M; every edge either belongs to M (both endpoints in $c_1$) or is not in M, in which case maximality of M forces at least one endpoint to already be matched by some edge of M (otherwise that edge could extend M), hence in $c_1$. $c_2$ (Algorithm 2) processes vertices from highest to lowest current degree and never terminates while an active vertex has positive degree, so every edge is incident to some vertex added to $c_2$ before both endpoints could reach degree 0 un-covered. $c_3$ represents every original edge $\{u,w\}$ by one auxiliary edge; when the endpoint processed first, say u, is scanned, the edge is either already covered (rule 1), or one of $u,w$ is selected (rules 2–3), or the scan of u stopped because u itself was selected, so every original edge is covered once all vertices are scanned. $c_4$ (Algorithm 3) adds, for every vertex v ever popped as the current minimum-degree active vertex, one of its active neighbors to the cover, which by the same maximal-matching-style argument as $c_1$ covers every edge incident to a processed vertex, and the loop runs until no active vertex remains. $c_5$’s primal-dual scan adds an endpoint of every edge whose slack is exhausted on both sides, which the local-ratio argument [15] guarantees for every edge. $c_6=SolveVC(G,\epsilon )$ is shown valid below. For $c_8$, every original edge $\{u,v\}$ is a forcing edge $\{x_{uv},x_{vu}\}$ of B (Lemma 1); the exact cycle solve returns a vertex cover of each gadget, so $x_{uv}$ or $x_{vu}$ is selected and u or v is decoded. In the residual variant every edge at the processed vertex u is covered either by u or by its decoded neighbours before u is deleted, and the loop runs until no residual edge remains.

$c_6$ validity (core path). The Baker PTAS pass returns a feasible IDS S of the gadget H. The variable edge $\left\{\right(v,0),(v,1\left)\right\}$ guarantees that at least one of $(v,0),(v,1)$ is dominated for every $v\in V\left(G_p\right)$. The repair loop then adds one endpoint of every core edge not yet covered by the decoded set $\{v:(v,0)\in S\}$, ensuring all core edges are covered.

$c_6$ validity (core and repair path). Let $G_p=(V,E_p)$ be the spanning-forest core, with $E_p\subseteq E$ and $V\left(G_p\right)=V$. The weighted MIDS pass and residual repair produce a cover valid for $G_p$. Every edge in $E\setminus E_p$ is inspected in the repair loop: if neither endpoint is in the running cover, the higher-degree endpoint is added. After the loop every edge of E has at least one endpoint in $c_6$.

(b) Pruning preserves validity. A vertex $v\in C$ is removed by Algorithm 8 only when every neighbour of v lies in C. In that case every edge incident to v is already covered by the neighbour side, so removing v leaves every edge covered.

(c) Unions of valid covers are valid. If $C_1$ and $C_2$ each cover every edge, then for every edge $(u,v)$ at least one of $u,v$ lies in $C_1\subseteq C_1\cup C_2$ (or in $C_2$), so $C_1\cup C_2$ covers $(u,v)$ as well; hence $c_7$’s starting union $c_1\cup \dots \cup c_6\cup c_8$ is valid before it, too, is pruned by (b).

(d) $c_9$ is valid. Algorithm 9 maintains an independent set S: a vertex is inserted only when it has no neighbour in S (it is free, or its solution neighbours were just evicted), and a $(1,2)$-swap inserts two non-adjacent vertices whose only solution neighbour was removed. The complement of an independent set is a vertex cover, so $c_9=V\setminus S$ is valid.    □

5. Approximation Ratio and Conditional Consequences

5.1. Structural Setup and Notation

Let $G=(V,E)$ be the input graph with $n=\left|V\right|$ and $m=\left|E\right|$. Write $\tau \left(G\right)$ for the size of a minimum vertex cover of G and let ${\tau }^{*}=\tau \left(G\right)$. Let $G_p=(V,E_p)$ be the spanning-forest core built by candidate $c_6$ (SolveVC), let H be its weighted MIDS gadget of Algorithm 4, and set ${\tau }_p^{*}=\tau \left(G_p\right)$.

5.2. An Unconditional Ratio-2 Guarantee for the Ensemble

Unlike the case-by-case bounds on the individual candidates below, the ensemble as a whole admits an immediate, unconditional worst-case guarantee.

Theorem 2

(Unconditional ratio 2). For every undirected graph G, Algorithm 1 returns a vertex cover C with $\left|C\right|\le 2\tau \left(G\right)$.

Proof. 

Candidate $c_1=MaximalMatchingCover\left(G\right)$ takes both endpoints of every edge of a maximal matching M of G, so $|c_1|=2|M|$. Because M is a matching, any vertex cover must contain at least one endpoint of each of its $\left|M\right|$ disjoint edges, so $\tau \left(G\right)\ge \left|M\right|$, giving $|c_1|\le 2\tau \left(G\right)$; this is the classical linear-time 2-approximation [2], and it is exactly the bound Hvala proves for its own ensemble [11]. Algorithm 1 prunes $c_1$ (Theorem 1 shows pruning preserves validity and cannot increase size) and then returns the smallest of nine valid covers including the pruned $c_1$, so $\left|C\right|\le |\mathrm{pruned}{c}_1|\le |c_1|\le 2\tau \left(G\right)$. The local-search candidate cannot break this: $|c_9|\le {min}_{i\le 8}\left|c_i\right|$.    □

Theorem 2 holds unconditionally, for every $\epsilon$ and every graph; it does not depend on the planar forest-core machinery, the bipartite planar reduction or the local search. It is the guarantee Salvador inherits by containing the Hvala ensemble: because the output is the minimum over a family of candidates that includes Hvala’s maximal-matching candidate, no other candidate can make it worse. The role of the remaining candidates—and of the structural analysis in this section—is to explain why the ensemble is expected to do far better than this worst-case guarantee in practice (Section 5.7).

5.3. Gadget Cost Identity for the SolveVC Candidate

Lemma 2

(Cost identity). For any planar graph G with n vertices and gadget hub penalty $P=n+1$, the minimum weighted MIDS cost of H equals ${\tau }^{*}$: ${\tau }_H^{*}=\tau \left(G\right)$.

Proof. 

Lower bound (${\tau }_H^{*}\ge {\tau }^{*}$). Let S be any feasible MIDS of H. For each hub $h_{uv}\notin S$, both $(u,0)$ and $(v,0)$ must be in S, so the edge $(u,v)$ is covered by $C_S=\{v\in V:(v,0)\in S\}$. Any hub $h_{uv}\in S$ contributes weight $P=n+1>n\ge {\tau }^{*}$, so any solution containing a hub has cost exceeding ${\tau }^{*}$. Hence the minimum-cost MIDS $S^{*}$ contains no hub and $C_{S^{*}}$ is a valid vertex cover of G with $\mathrm{cost}\left(S^{*}\right)=\left|C_{S^{*}}\right|\ge {\tau }^{*}$.

Upper bound (${\tau }_H^{*}\le {\tau }^{*}$). Let $C^{*}$ be an optimal vertex cover with $|C^{*}|={\tau }^{*}$. Define $S^{*}=\{(v,0):v\in C^{*}\}\cup \{(v,1):v\notin C^{*}\}$. Every hub $h_{uv}$ has at least one of $(u,0),(v,0)$ in $S^{*}$ because $C^{*}$ covers $(u,v)$; every variable-edge node is dominated by its companion. Thus $S^{*}$ is a valid MIDS of H with $\mathrm{cost}\left(S^{*}\right)=\left|C^{*}\right|={\tau }^{*}$, giving ${\tau }_H^{*}\le {\tau }^{*}$.    □

In Algorithm 4 the gadget is built from the spanning-forest core $G_p$, so Lemma 2 applies with the core $G_p$ in the role of G, yielding ${\tau }_H^{*}=\tau \left(G_p\right)$. Because H is a forest, the per-component tree dynamic program is exact; the Baker PTAS, however, only explores the $k=\lceil 1/\epsilon \rceil$ layer shifts, so at a fixed $\epsilon$ the decoded set is a near-minimum—not necessarily minimum—cover of the core. The total approximation loss is this layering slack plus the greedy repair of the non-core edges $E\setminus E_p$.

5.4. Elementary Bounds on the SolveVC Candidate

The next two results are stated for $c_6$ in isolation (they are properties of the candidate SolveVC produces before the ensemble compares it against $c_1,\dots ,c_5,c_7$); they are superseded, as guarantees on the algorithm’s output, by Theorem 2, but they explain why$c_6$ is a useful candidate to include rather than redundant with the others.

Proposition 1

(Elementary bounds on $c_6$). For every graph G with n vertices and m edges, the candidate cover $c_6$ produced by Algorithm 4 satisfies $|c_6|\le min\{n,m\}$ and is a valid vertex cover of G.

Proof. 

Validity is Theorem 1 restricted to the $c_6$ path. The decoded core cover has size at most $\left|V\right(G_p\left)\right|=n$, each repair step adds at most one vertex and is triggered at most once per edge, so $|c_6|\le n$ and $|c_6|\le |\mathrm{core}\mathrm{cover}|+m$; pruning only removes vertices.    □

5.5. Linear Core Guarantee for SolveVC

Theorem 3

(Core cover guarantee). For any input graph G, Algorithm 4 covers every edge of the spanning-forest core $G_p$ before the final repair scan and covers every edge of G after the repair scan.

Proof. 

The MIDS pass produces an independent dominating set of H. Decoding selects each v whose node $(v,0)$ appears in this set. If a core edge $(u,v)\in E_p$ is not covered by the decoded set, the residual core-repair loop adds one endpoint, so all edges of $G_p$ are covered. The final repair loop scans $E\setminus E_p$ and adds one endpoint for every still-uncovered edge, so every original edge is covered.    □

5.6. Non-Planar Case

Lemma 3

(Subgraph optimality). ${\tau }_p^{*}\le {\tau }^{*}$.

Proof. 

Any vertex cover of G is also a vertex cover of $G_p\subseteq G$.    □

Proposition 2

(Repair bound). For any input G, the $c_6$ path of Algorithm 4 adds at most one repair vertex per edge in $E\setminus E_p$ after the core solve.

Proof. 

The repair loop visits each edge in $E\setminus E_p$ once. It does nothing when an endpoint is already in the candidate cover and otherwise adds exactly one endpoint. Thus the number of repair additions is at most $|E\setminus E_p|$.    □

In practice the $c_6$ repair adds far fewer vertices than Proposition 2 suggests, because most removed edges are already covered by the near-optimal core solution on $G_p$; and even where $c_6$ overshoots, the ensemble as a whole is protected by Theorem 2 and by the other candidates.

5.7. The Empirical Conjecture for the Ensemble

Because the candidates draw on structurally different techniques—maximal matching, degree-greedy, degree-1 reduction, Min-to-Min, primal-dual, the planar forest-core MIDS reduction, the bipartite planar reduction, and local search—and the ensemble takes the smallest of all of them, we expect the ensemble’s worst case to sit strictly below the unconditional bound of Theorem 2, which is attained only when every candidate simultaneously realises its own worst case on the same instance.

Conjecture 1

(Universal ensemble approximation ratio). There is a constant $R^{★}<2$ such that, for every undirected graph G, Algorithm 1 with the default parameter $\epsilon =1$ returns a vertex cover C with

$$\left|C\right|\le R^{★}\tau \left(G\right).$$

Conjecture 1 is not a theorem; Theorem 2 is the only unconditional bound proved in this paper. Section 7 reports empirical support for the conjecture: on a reproducible suite of $1,746$ test graphs, the exact or certified ratio never exceeds $1.17$. Because this is far below $\sqrt{2}\approx 1.4142$, we also state the following stronger conjecture, with the explicit constant of the earlier version of this work.

Conjecture 2

(Universal $7/5$-approximation). For every undirected graph G, Algorithm 1 with the default parameter $\epsilon =1$ returns a vertex cover C with

$$\left|C\right|\le \frac{7}{5}\tau \left(G\right)=(\sqrt{2}-{\epsilon }_0)\tau \left(G\right),{\epsilon }_0=\sqrt{2}-\frac{7}{5}\approx 0.0142>0.$$

The constant matters: the hardness barrier of Section 5.10 is $\sqrt{2}-\epsilon$ for every fixed $\epsilon >0$, so a ratio of exactly $\sqrt{2}$ would contradict nothing. A consequence for $\mathrm{P}$ versus $\mathrm{NP}$ requires a constant strictly below $\sqrt{2}$, such as $7/5$.

5.8. Why the Ratio Stays Low Across Graph Classes

The ensemble’s low observed ratio rests on running several structurally different heuristics and taking the best. Four candidates are the Hvala ensemble (Section 3.2), whose worst case is $\Theta (log\Delta )$ for $c_2$ but 2 for $c_1$ alone; two are Salvador-specific 2-approximations ($c_4$, $c_5$); and $c_6$ additionally exploits planar/forest structure via the weighted MIDS gadget (Section 5.2 onward). Because the gadget H built from the $c_6$ forest core is itself a forest, its per-component tree dynamic program is exact, so on graphs close to forests $c_6$ alone is already near-optimal (Lemma 2); on graphs where $c_6$’s non-core repair overshoots, one of $c_1,\dots ,c_5$ typically does not, and the final redundancy-pruning pass removes any vertex all of whose incident edges are already covered from every candidate.

Classes solved optimally by $c_6$ alone.

On stars $K_{1,k}$ the $c_6$ core is the whole star, whose minimum cover is the centre alone; the decode returns it. On a matching the core is the matching itself and the decode returns one endpoint per edge. Forests and trees (paths, caterpillars, spiders, brooms) and cycles are solved exactly because the gadget reproduces the tree optimum, and the ensemble inherits this exactly.

Dense and degree-heterogeneous classes.

Complete graphs$K_n$ have $\tau =n-1$; the $c_6$ spanning-tree core is solved and the dense non-core edges are absorbed, returning the optimal $(n-1)$-cover, and $c_1$ (maximal matching) independently gets within a factor 2. Wheels$W_n$, barbell and lollipop graphs concentrate their optima on hub or clique vertices, captured by either $c_2$ (max-degree greedy) or the $c_6$ core.

Bipartite and planar classes.

For bipartite graphs Konig’s theorem makes $\tau$ equal to the maximum matching; on this class $c_1,\dots ,c_5$ each provide independent coverage, so the ensemble does not depend solely on $c_6$’s core solve. Grids and other bounded-treewidth planar families remain mild for $c_6$ alone, since the forest core captures $n-1$ of the at most $3n-6$ edges and only $O\left(n\right)$ non-core edges reach the repair.

Large adversarial graphs.

Complete bipartite graphs, crown graphs ($K_{h,h}$ minus a perfect matching), double stars joined by a bridge, a hierarchical greedy-tie-break stress construction, random regular graphs, Barabasi–Albert scale-free graphs, sparse Erdos–Renyi graphs, and Watts–Strogatz small-world graphs are designed to stress individual candidates (dense structure, high or irregular degree, small-world shortcuts); the ensemble’s minimum-over-candidates guarantee (Theorem 2) still applies unconditionally to every one of them. Section 7.4 reports which candidate wins on each family.

5.9. Conditional Consequence for the Unique Games Conjecture

Theorem 4

(UGC consequence of a universal sub-2 bound). If Conjecture 1 were proved for some constant $R^{★}<2$, then Algorithm 1 would be a polynomial-time $R^{★}$-approximation for Minimum Vertex Cover. Consequently, under the standard assumption $\mathrm{P}\ne \mathrm{NP}$, the Unique Games Conjecture would be false.

Proof. 

The runtime theorem (Theorem 6) gives worst-case $O(n+m)$ time for the default fixed $\epsilon =1$, in particular polynomial time. A proof of Conjecture 1 would therefore give a polynomial-time approximation ratio $R^{★}=2-\delta$ with $\delta =2-R^{★}>0$. Khot and Regev [10], assuming the Unique Games Conjecture [9], showed that Vertex Cover is hard to approximate within factor $2-\delta$ for every fixed $\delta >0$. Therefore, if $\mathrm{P}\ne \mathrm{NP}$, the simultaneous truth of UGC and Conjecture 1 would be impossible. Hence a proof of Conjecture 1 would refute UGC under $\mathrm{P}\ne \mathrm{NP}$.    □

Remark 3.

Theorem 4 is conditional and, unlike Theorem 2, not unconditionally established here: Theorem 2 proves $R=2$ exactly, which is the UGC threshold itself and yields no contradiction ($\delta =0$). Conjecture 1 neither disproves UGC nor proves an $R^{★}<2$ approximation theorem on its own; establishing it for some concrete $R^{★}<2$, by whatever means, is what would trigger Theorem 4’s consequence. The empirical results of Section 7, while consistent with Conjecture 1, are evidence, not a proof, and do not by themselves establish any $R^{★}<2$ bound.

5.10. Conditional Consequence for P Versus NP

Theorem 5

($\mathrm{P}=\mathrm{NP}$ consequence of Conjecture 2). If Conjecture 2 were proved, then $\mathrm{P}=\mathrm{NP}$.

Proof. 

Khot, Minzer, and Safra [6,7,8] proved the 2-to-2 games conjecture and derived from it that, for every fixed $\delta >0$, approximating Minimum Vertex Cover within factor $\sqrt{2}-\delta$ is NP-hard. Algorithm 1 runs in polynomial time (Theorem 6). A proof of Conjecture 2 would make it a polynomial-time $(\sqrt{2}-{\epsilon }_0)$-approximation with ${\epsilon }_0=\sqrt{2}-7/5>0$, i.e. of the form $\sqrt{2}-\delta$ with $\delta ={\epsilon }_0$, so an NP-hard problem would be solved in polynomial time, and $\mathrm{P}=\mathrm{NP}$.    □

Remark 4.

Theorem 5 is a conditional implication, not a proof of $\mathrm{P}=\mathrm{NP}$. Its hypothesis is a worst-case statement overeverygraph, whereas the experiments of Section 7 cover finitely many graphs drawn from specific families, so they are evidence for Conjecture 2, not a proof of it. The only ratio proved here is 2 (Theorem 2), which Salvador inherits from the Hvala ensemble it contains; that bound is the classical one and contradicts neither hardness result. Establishing Conjecture 2—or any constant bound strictly below $\sqrt{2}$—remains open, and, given the implication above, would require settling one of the central open problems of complexity theory.

6. Runtime Analysis

Theorem 6.

For the default accuracy $\epsilon =1$, Algorithm 1 runs in worst-case time $O(n+m)$, where $n=\left|V\right|$ and $m=\left|E\right|$. For a fixed $\epsilon \in (0,1]$ in general, candidate $c_6$ alone costs $O\left((n+m)\left(\alpha \left(n\right)+1/\epsilon \right)\right)$, where α is the inverse Ackermann function, so the whole ensemble costs $O\left((n+m)\left(\alpha \left(n\right)+1/\epsilon \right)\right)$ for general ε and strictly $O(n+m)$ at the default $\epsilon =1$.

Proof. 

We bound each of the nine candidates and the shared preprocessing and pruning; the ensemble cost is the sum of a constant number of $O(n+m)$-or-better terms.

Preprocessing. Removing self-loops and isolated vertices is one scan of the edge list and one scan of the vertex list, costing $O(n+m)$.

$c_1$, maximal matching. A greedy maximal matching is computed in one scan of the edge list, $O(n+m)$ [2].

$c_2$, bucket-queue max-degree greedy (Algorithm 2). Standard bucket-queue argument: every push corresponds to an initial vertex or a degree decrement, and there are at most $2m$ decrements in total, so there are $O(n+m)$ pushes and pops, each $O\left(1\right)$; total $O(n+m)$.

$c_3$, degree-1 weighted reduction. The auxiliary instance has $2m$ vertices and m edges (one auxiliary vertex per original edge occurrence). The selection-aware resolution bucket-sorts the original vertices by degree in $O(n+m)$ and inspects each auxiliary edge at most twice, once from each endpoint, with $O\left(1\right)$ work per inspection; it is run twice (unweighted and weighted), a constant factor. Total $O(n+m)$.

$c_4$, Min-to-Min (Algorithm 3). By the same bucket-queue argument as $c_2$: total pushes are n initial pushes plus at most $2m$ degree-decrement pushes plus, for each real (non-stale) pop of a vertex v, at most one requeue of v itself (its degree strictly decreases by 1 whenever it is processed, since its chosen neighbor $\mathit{target}$ is removed), giving $O(n+m)$ pushes and pops overall; each pop does $O\left(1\right)$ work (a stale check, or an $O\left(1\right)$ arbitrary-neighbor selection followed by the standard $O\left(1\right)$-amortized degree-bucket update). Total $O(n+m)$ (see also Remark 1).

$c_5$, primal-dual weighted cover. One pass over the edge list with $O\left(1\right)$ work per edge, $O(n+m)$.

$c_6$,SolveVC(Algorithm 4).SpanningForestCore initialises the disjoint-set forest in $O\left(n\right)$ and performs mUnion/Find pairs, one per edge; with union by rank and path halving this costs $O\left((n+m)\alpha \left(n\right)\right)$ in the worst case, tight for path-compression heuristics [17]. For a forest core $G_p$ with $|E_p|\le n-1$ edges, the gadget H has $\left|V\left(H\right)\right|=2n+|E_p|\le 3n-1$ vertices and $\left|E\left(H\right)\right|=n+2|E_p|\le 3n-2$ edges, so H is built in $O\left(n\right)$; crucially H is itself a forest, hence of treewidth 1. BakerPtasWeightedIDS uses $k=\lceil 1/\epsilon \rceil$ shifts; each shift removes one BFS residue class, splits the rest into components, and solves each by the tree dynamic program ExactWeightedIDS, which runs in time linear in component size since H is a forest, so one shift costs $O\left(\right|V\left(H\right)|+|E\left(H\right)\left|\right)=O\left(n\right)$, and the pass costs $O\left(kn\right)=O(n/\epsilon )$ over k shifts. At the default $\epsilon =1$, $k=1$ and BakerPtasWeightedIDS returns the $O\left(n\right)$ greedy baseline GreedyWeightedMIS directly (Algorithm 5, line 2), skipping the layering loop entirely, so this phase is $O\left(n\right)$ rather than $O(n/\epsilon )$. The repair loops inspect each edge of $E_p$ and of $\mathit{removed}=E\setminus E_p$ once with $O\left(1\right)$ degree look-ups, $O(n+m)$. Total for $c_6$: $O\left((n+m)\left(\alpha \right(n)+1)\right)=O\left((n+m)\alpha \left(n\right)\right)$ at $\epsilon =1$, and $O\left((n+m)\left(\alpha \right(n)+1/\epsilon )\right)$ for general $\epsilon$.

$c_8$, bipartite planar reduction (Algorithm 7). By Lemma 1 the auxiliary graph has $2m$ nodes and at most $2m$ edges, arranged in vertex-disjoint cycles and single edges; the gadget of u is built and solved by the cycle dynamic program in $O\left(d_u\right)$ time, where $d_u$ is the number of edges handled at u, and ${\sum }_u{d}_u=m$. The processing order is either the input order or, for the residual variant, maintained by a degree-indexed bucket queue: each residual edge deletion is $O\left(1\right)$ and lowers the minimum-bucket pointer by at most one, so pointer movements total $O(n+m)$. Both variants and their pruning cost $O(n+m)$.

$c_9$, local search (Algorithm 9). Initialisation (indexing, tightness counters, maximality) is $O(n+m)$. Every later operation is charged its exact adjacency-scan cost to a work counter, and the search stops as soon as the counter exceeds $b(n+m)$ for the fixed constant b (default 100); the swap test never scans more than the charged degrees (Section 3.7). Total $O(n+m)$.

Pruning.PruneRedundantVertices (Algorithm 8) builds the adjacency map in $O(n+m)$ and makes one pass of total work ${\sum }_{v\in C}{deg}_G\left(v\right)=O(n+m)$; it is applied to each of $c_1,\dots ,c_6$, to the two variants of $c_8$, and once more to the union, a constant number of $O(n+m)$ passes.

Summing over a constant number (9) of candidates plus preprocessing and pruning, every term is $O(n+m)$ except $c_6$’s union-find pass, which contributes the extra $O\left((n+m)\alpha \left(n\right)\right)$ factor common to all disjoint-set algorithms with path compression. Since $\alpha \left(n\right)=O\left(1\right)$ for all n of practical relevance (indeed for all n up to far beyond the number of atoms in the observable universe), the ensemble is $O(n+m)$ for every fixed $\epsilon$ in the sense that matters computationally, and strictly $O(n+m)$ (no $1/\epsilon$ factor at all) at the default $\epsilon =1$, since the layering loop is skipped.    □

Remark 5.

Because the gadget H built by $c_6$ is a forest, the minimum-weight independent dominating set of H can in fact be computed exactly in $O\left(n\right)$ time by a single tree dynamic program, making the Baker layering unnecessary in principle; the layered PTAS is retained because the implementation reuses the general bounded-treewidth solver, and at the default $\epsilon =1$ it is bypassed anyway (Algorithm 5, line 2). The $\alpha \left(n\right)$ union-find factor in $c_6$ can likewise be removed by building the spanning-forest core with a depth-first traversal, yielding a strictly $O(n+m)$$c_6$ candidate (matching $c_1$–$c_5$) if desired. The scaling study of Section 7 empirically confirms this near-linear growth, fitting wall-clock time against $n+m$ with $R^2>0.99$ on two doubling-size graph families.

7. Reproducible Experiment

To assess Conjectures 1 and 2, we ran the Salvador package (v0.0.9, default $\epsilon =1$) on a reproducible suite of test graphs with a fixed random seed (20260627). The suite is distributed with the package as three scripts: car/car_ratio.py (approximation ratio, Parts A and B), car/car_scaling.py (doubling-size timing study) and car/car_strategies.py (which candidate wins, Section 7.4). Part C compares Salvador with Hvala on the DIMACS clique complements of NPBench, using the log of a separate run (Section 7.3).

7.1. Part A: Small Graphs with a Known Optimum

Part A collects $1,718$ small graphs for which $\tau \left(G\right)$ is known exactly, either via Konig’s theorem on bipartite instances or by exact branch-and-bound search otherwise: graphs of order at most 7 drawn exhaustively from the graph atlas, bipartite hill-climbing and obstruction instances, bipartite grids, random bipartite and general graphs, and relabeling/vertex-order stress instances. Table 2 reports, for every family, the ratio $\left|C\right|/\tau \left(G\right)$ of the returned cover to the exact optimum.

7.2. Part B: Large and Adversarial Graphs with Certified Bounds

Exact optima are out of reach at the scale of Part B, so for each instance we compute a certified lower bound $L\le \tau \left(G\right)$ and report $\left|C\right|/L$, which is an upper bound on the true ratio $\left|C\right|/\tau \left(G\right)$. Earlier versions used a greedy maximal matching for L. Every matching satisfies $\left|M\right|\le n/2$, while on random d-regular or locally dense graphs $\tau \left(G\right)$ is much larger than $n/2$, so that bound alone cannot certify ratios below roughly $1.4$–$1.6$ on these families however good the cover is. Version 0.0.9 takes L as the largest of the following bounds, each valid for every graph:

• Exact bipartite matching. On bipartite graphs a Hopcroft–Karp maximum matching [18] gives $L=\tau \left(G\right)$ by Konig’s theorem [19], so the reported ratio is exact.
• Matchings. Any matching M gives $\tau \left(G\right)\ge \left|M\right|$. We use the greedy maximal matching of earlier versions and a Karp–Sipser matching [20], which matches degree-1 vertices first and is near-maximum on sparse graphs.
• Clique packing. A cover contains all but at most one vertex of every clique, and vertex-disjoint cliques need disjoint cover vertices, so for vertex-disjoint cliques $K_1,\dots ,K_t$ we have $\tau \left(G\right)\ge {\sum }_i\left(\right|K_i|-1)$; a matching is the case $|K_i|=2$. We pack cliques greedily.
• Spectral bound. For an independent set S with $\left|S\right|=s$, the vector $x={\mathbf{1}}_S-\frac{s}{n}\mathbf{1}$ satisfies $x^{\top }Lx=e(S,V\setminus S)\ge s\delta$ and $x^{\top }x=s(n-s)/n$, where L is the Laplacian and $\delta$ the minimum degree (isolated vertices removed). Hence $\alpha \left(G\right)\le n(1-\delta /{\mu }_{max})$ and $\tau \left(G\right)\ge n-\lfloor n(1-\delta /{\mu }_{max})\rfloor$; on d-regular graphs this is Hoffman’s ratio bound [21]. The largest Laplacian eigenvalue ${\mu }_{max}$ is computed by Lanczos iteration, inflated by its residual norm, and capped by the rigorous Anderson–Morley bound ${\mu }_{max}\le {max}_{uv\in E}(degu+degv)$; this bound is therefore certified up to the numerical eigenvalue computation.

Table 3 reports, for the ten families, the largest instance size, the certified ratio bound with the method that attained it, the bound that the greedy maximal matching alone would give, and the wall-clock time.

Across the 28 Part B instances the certified ratio bound never exceeds $1.1694$, attained on the random 12-regular graph with $n=200,000$ vertices and $m=1,200,000$ edges, where the cover has $150,628$ vertices and the spectral bound certifies $\tau \left(G\right)\ge 128,812$. With the matching bound alone the largest value would have been $1.576$; the difference comes from the sharper lower bounds, not from the covers, and the true ratios may be smaller still. Combined with Part A, the exact or certified ratio across all $1,746$ test graphs never exceeds $1.17$, below $7/5$ (Conjecture 2) and well below the unconditional bound of 2 (Theorem 2). These numbers are evidence on the families tested; they do not bound the ratio on graphs outside the suite.

7.3. Part C: DIMACS Clique Complements, Compared with Hvala

Because Salvador contains the Hvala ensemble [11], a natural question is how much its additional candidates improve on Hvala alone. We answer it on the 68 DIMACS clique-complement instances of the NPBench collection [22]. The minimum vertex cover of the complement of a graph G on n vertices has size $n-\omega \left(G\right)$, where $\omega \left(G\right)$ is the clique number; we use the clique numbers compiled by Mascia [23]. For 66 of the 68 instances $\omega \left(G\right)$ is certified, so the reported ratio is a certified approximation ratio; for C500.9 and C1000.9 only best-known lower bounds on $\omega \left(G\right)$ are available, so these two instances are marked with ${}^{†}$ and their ratios are ratios to a best-known reference value. The Hvala columns of Table 4 and Table 5 are the figures reported for Hvala in [11]; the Salvador columns come from the raw log of one run of the Salvador package (v0.0.9, default $\epsilon =1$) on the same 68 instances.

Salvador is never worse than Hvala on any of the 68 instances: it returns a strictly smaller vertex cover on 48 instances and the same cover size on the remaining 20. The mean ratio to the known optimum is $1.014$ for Salvador against $1.025$ for Hvala, and the maximum ratio is $1.162$ against $1.192$, both attained on san200_0.9_1. Salvador attains the known optimum on 29 instances, whereas Hvala does so on 18, and the total cover size summed over the 68 instances is $26,376$ for Salvador against $26,603$ for Hvala.

The largest improvements occur on san400_0.9_1, where Salvador returns the optimum (300) against 348 for Hvala, and on gen400_p0.9_75 (347 against 358); an improvement of 8 vertices is obtained on each of C250.9, C500.9, C1000.9, gen400_p0.9_65 and keller5. Salvador wins on every instance of the brock, gen, C, keller, san and sanr families, and on nine of the ten p_hat instances, whereas the two algorithms tie on the c-fat and johnson families and on most hamming and MANN instances, where both are already at or very near the optimum. Because Salvador returns the smallest of its candidates and Hvala’s candidates are among them, it cannot be worse than Hvala by construction (Theorem 2); the experiment measures by how much the additional candidates help, and the answer is that they help on most instances and on every family where Hvala is not already optimal.

The cumulative algorithm time is $37.6$ seconds for Salvador against $121.4$ seconds for Hvala, and Salvador is faster on 64 of the 68 instances. This timing comparison is indicative only, since the two sets of times come from separate single-run logs. The maximum ratio $1.162$ is consistent with the bound of $1.17$ observed on the suite of Parts A and B; the 68 instances of Part C are external benchmark instances and are not included in the count of $1,746$ test graphs.

7.4. Which Candidate Wins

Table 6 reports, over $1,659$ instances (the non-adaptive Part A families and the Part B families up to $n=50,000$), how often each of $c_1,\dots ,c_8$ attains the smallest cover among them (ties credit every tied candidate) and how often it is the sole winner. Because $c_9$ starts from that smallest cover, it is reported separately, by the number of instances on which it strictly improved it.

The local search $c_9$ strictly improved the best of $c_1,\dots ,c_8$ on 12 of the $1,659$ instances: every large random regular, Erdos–Renyi, Barabasi–Albert and Watts–Strogatz instance in the run, and none of the small or bipartite instances, where $c_1,\dots ,c_8$ are already optimal or exact. Table 7 lists the gains.

7.5. Scaling Study

To check the $O(n+m)$ bound of Theorem 6 empirically, car/car_scaling.py runs the ensemble on two families of doubling size—4-regular graphs and Barabasi–Albert graphs with attachment parameter 3—and fits wall-clock time against $n+m$ by ordinary least squares. With the seven-candidate ensemble of version 0.0.7 the fit was close to linear from $n=1,000$ to $n=128,000$ ($R^2=0.9945$ and $R^2=0.9968$). The candidates added in version 0.0.9 are linear by construction; timing them alone while doubling n from $25,000$ to $200,000$ kept the time per unit of $n+m$ roughly flat for both variants of $c_8$ on 4-regular, Barabasi–Albert and star-plus-path graphs.

8. Conclusion

We have presented the Salvador algorithm (v0.0.9), an ensemble approximate solver for Minimum Vertex Cover that computes nine valid candidate covers and returns the smallest. Four candidates and the pruning pass adapt the Hvala ensemble [11], which Salvador therefore contains; the others are a Min-to-Min heuristic, a primal-dual 2-approximation, a planar forest-core MIDS reduction, the bipartite planar oriented-incidence reduction—now solved exactly in linear time thanks to Lemma 1—and a budgeted $(1,2)$-swap local search. The algorithm always returns a valid vertex cover (Theorem 1), unconditionally achieves approximation ratio at most 2 on every graph (Theorem 2), and runs in worst-case $O(n+m)$ time at the default $\epsilon =1$ (Theorem 6).

On a reproducible suite of $1,746$ test graphs, the ratio is exactly 1 on all $1,718$ graphs with known optima, and the certified ratio bound never exceeds $1.17$ on the 28 large adversarial graphs. Most of the improvement over the $1.604$ reported for version 0.0.7 comes from sharper certified lower bounds rather than smaller covers, although the new local search reduces the covers on every large non-bipartite instance. We conjecture a universal ratio below 2 (Conjecture 1) and, more strongly, at most $7/5=\sqrt{2}-{\epsilon }_0$ (Conjecture 2). Both are conditional statements with major consequences: a proof of the first would refute the Unique Games Conjecture under $\mathrm{P}\ne \mathrm{NP}$ (Theorem 4), and a proof of the second would imply $\mathrm{P}=\mathrm{NP}$ by the Khot–Minzer–Safra theorem (Theorem 5). On the 68 DIMACS clique-complement instances of NPBench, Salvador never returns a larger cover than the Hvala algorithm it contains, returns a strictly smaller one on 48 instances, and reduces the mean ratio from $1.025$ to $1.014$ (Section 7.3). The experiments support these conjectures on the families tested but do not prove them.

Future work includes: (i) establishing or refuting Conjectures 1 and 2, either by a structural analysis of which candidate wins on which graph class or by a large-scale search for adversarial instances; (ii) exact optima, or sharper certified bounds, on the large regular families where the certified bound is currently loosest; (iii) analysing the residual bipartite planar reduction and the local search theoretically; and (iv) extending the ensemble methodology to dominating set, independent set, and set cover. The implementation is freely available as the Salvador package (v0.0.9) on PyPI [14].