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-\mathrm{\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 under the Unique Games Conjecture [6], Khot and Regev [7] showed that no polynomial-time algorithm can approximate Minimum Vertex Cover within factor $2-\epsilon$ for any fixed $\epsilon >0$. Thus a proved constant sub-2 approximation ratio for a polynomial-time algorithm would have direct consequences for the Unique Games Conjecture, conditional on the standard belief that $\mathrm{P}\ne \mathrm{NP}$.

Against this backdrop, we present an algorithm—implemented as the Salvador Python package (v0.0.7)—that, on every instance we have tested under the default call $\epsilon =1$, produces a vertex cover whose size is provably never more than twice the optimum and, empirically, far closer to it. The algorithm, called FindVertexCover, is an ensemble: it runs seven independently valid vertex-cover heuristics and returns the smallest cover among them, then a final pruning pass removes any remaining redundant vertices. Four of the seven candidates and the pruning pass adapt the ensemble published as the Hvala algorithm [8,9], which proves an unconditional $O(n+m)$ time and space bound and worst-case approximation ratio at most 2; Salvador adds two further linear-time candidates of its own together with a sixth candidate, SolveVC, described below. The algorithm operates in three 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. Six 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 [8]); a Min-to-Min bucket heuristic and a primal-dual/local-ratio 2-approximation (both Salvador-specific); and SolveVC, which reduces G to a weighted MIDS instance on a planar forest-core gadget H and solves H with an accuracy-controlled Baker-style PTAS [10] of layering width $k=\lceil 1/\epsilon \rceil$, repairing non-core edges greedily. At the default $\epsilon =1$, $k=1$ and the PTAS pass degenerates to its linear-time greedy baseline.

3.

Linear-time pruning.PruneRedundantVertices (Hvala’s fourth strategy) makes a single forward pass over each candidate cover C and removes every vertex all of whose neighbours are already covered; it is applied to every one of the six candidates and to their union, and the smallest resulting cover is returned.

At the default $\epsilon =1$ every one of the seven 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)$: strictly linear, not merely near-linear. This holds in particular for the Min-to-Min heuristic, whose bucket-queue argument (Section 3) pops and processes one minimum-degree vertex per step, so its cover target is selected in $O\left(1\right)$ time without rescanning a bucket.

Contributions

The main contributions of this paper are:

• A linear-time ensemble vertex-cover algorithm, four of whose seven candidates adapt the published Hvala ensemble [8], extended with a Min-to-Min heuristic, a primal-dual 2-approximation, and a planar forest-core reduction to a weighted MIDS gadget solved by an accuracy-controlled Baker-style PTAS. At the default $\epsilon =1$ every candidate—and hence the ensemble—runs in worst-case $O(n+m)$ time.
• An unconditional (not merely conjectured) worst-case approximation ratio of at most 2 for the ensemble on every graph, inherited directly from the classical maximal-matching candidate together with the fact that taking the minimum over valid covers, then pruning, cannot increase cover size.
• An empirical conjecture (Conjecture 1) that the universal approximation ratio under the default call is well below the unconditional bound of 2, supported by a reproducible suite of $1,746$ test graphs (Section 7) on which the observed or bounded ratio never exceeds $1.61$.
• A conditional UGC consequence: under $\mathrm{P}\ne \mathrm{NP}$, any proof of a universal ratio below 2 for this polynomial-time ensemble would refute the Unique Games Conjecture via the Khot–Regev hardness theorem.
• An open-source implementation, Salvador v0.0.7, in which the accuracy parameter $\epsilon$ still drives the Baker PTAS candidate but no longer the whole algorithm’s linear-time guarantee.

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 consequences for the Unique Games Conjecture. 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 [11]. The current version is v0.0.7; 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, and the local reduction gadget of the SolveVC candidate is depicted in Figure 1.

3. Description of the Algorithm

Salvador’s entry point, FindVertexCover (Algorithm 1), is an ensemble: it computes six independently valid candidate covers $c_1,\dots ,c_6$ by six different linear-time heuristics, prunes each with PruneRedundantVertices, additionally prunes their union to form a seventh candidate $c_7$, and returns the smallest of the seven. Four of the six 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 [8,9], which proves these run in $O(n+m)$ time and space and that the best of them alone already achieves worst-case approximation ratio at most 2. Salvador adds two further linear-time candidates, the Min-to-Min heuristic ($c_4$) and a primal-dual/local-ratio 2-approximation ($c_5$), and a sixth candidate ($c_6$) produced by SolveVC, the planar forest-core reduction to a weighted MIDS gadget described below. We present pseudocode for the main ensemble, each of the six 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 {\mathrm{M}}_{\mathrm{AXIMAL}}{\mathrm{M}}_{\mathrm{ATCHING}}{\mathrm{C}}_{\mathrm{OVER}}\left(G\right)$                               ▹ Hvala strategy 1   7: $c_2\leftarrow {\mathrm{B}}_{\mathrm{UCKET}}{\mathrm{D}}_{\mathrm{EGREE}}{\mathrm{G}}_{\mathrm{REEDY}}\left(\mathit{adj}\right)$                                      ▹ Hvala strategy 2   8: $c_3\leftarrow {\mathrm{R}}_{\mathrm{EDUCTION}}{\mathrm{M}}_{\mathrm{AX}}{\mathrm{D}}_{\mathrm{EGREE}}{\mathrm{O}}_{\mathrm{NE}}\left(G\right)$               ▹ Hvala strategy 3, "Hallelujah"   9: $c_4\leftarrow {\mathrm{M}}_{\mathrm{IN}}{\mathrm{T}}_{\mathrm{O}}{\mathrm{M}}_{\mathrm{IN}}{\mathrm{C}}_{\mathrm{OVER}}\left(\mathit{adj}\right)$                                       ▹ Salvador-specific 10: $c_5\leftarrow {\mathrm{L}}_{\mathrm{INEAR}}{\mathrm{W}}_{\mathrm{EIGHTED}}{\mathrm{C}}_{\mathrm{OVER}}\left(G\right)$               ▹ Salvador-specific, primal-dual 11: $c_6\leftarrow {\mathrm{S}}_{\mathrm{OLVE}}\mathrm{VC}(G,\epsilon )$               ▹ Salvador-specific, planar MIDS reduction 12: for $i\leftarrow 1$to 6 do 13:     $c_i\leftarrow {\mathrm{P}}_{\mathrm{RUNE}}{\mathrm{R}}_{\mathrm{EDUNDANT}}{\mathrm{V}}_{\mathrm{ERTICES}}(\mathit{adj},c_i)$               ▹ Hvala strategy 4, applied to every candidate 14: end for 15: $c_7\leftarrow {\mathrm{P}}_{\mathrm{RUNE}}{\mathrm{R}}_{\mathrm{EDUNDANT}}{\mathrm{V}}_{\mathrm{ERTICES}}(\mathit{adj},c_1\cup c_2\cup c_3\cup c_4\cup c_5\cup c_6)$ 16: return$arg{min}_{i\in \{1,\dots ,7\}}\left|c_i\right|$

3.2. The Hvala-Adapted Candidates

Candidates $c_1$, $c_2$, and $c_3$, and the pruning pass shared by all seven candidates, adapt the ensemble of Vega’s Hvala algorithm [8], which proves an unconditional $O(n+m)$ time and space bound and worst-case approximation ratio at most 2 for every graph. M_AXIMALM_ATCHINGC_OVER $\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]. B_UCKETD_EGREEG_REEDY $\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 $\mathrm{\Theta }(log\Delta )$ by Johnson’s classical bound [2], where $\Delta$ is the maximum degree. R_EDUCTIONM_AXD_EGREEO_NE $\left(G\right)$ (Hvala strategy 3, the "Hallelujah heuristic") subdivides every edge $(u,v)$ into an auxiliary degree-1 instance, solves it exactly (a degree-1/star instance has a trivial optimum), and maps the solution back to G; because the auxiliary instance has $O\left(m\right)$ vertices and edges, this runs in $O(n+m)$ time.

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

L_INEARW_EIGHTEDC_OVER$\left(G\right)$ ($c_5$) is a single $O(n+m)$ pass implementing the primal-dual/local-ratio method [12]: 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.

M_INT_OM_INC_OVER$\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 5), 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: return  C

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 {\mathrm{S}}_{\mathrm{PANNING}}{\mathrm{F}}_{\mathrm{OREST}}{\mathrm{C}}_{\mathrm{ORE}}\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 {\mathrm{B}}_{\mathrm{AKER}}{\mathrm{P}}_{\mathrm{TAS}}{\mathrm{W}}_{\mathrm{EIGHTED}}\mathrm{IDS}(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: return  C

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 5). 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$  then  returnGreedyWeightedMIS$\left(H\right)$   3: end if               ▹ cheap baseline   4: $\ell \leftarrow$ BFS-distance layering of H   5: $S^{\star }\leftarrow {\mathrm{G}}_{\mathrm{REEDY}}{\mathrm{W}}_{\mathrm{EIGHTED}}\mathrm{MIS}\left(H\right)$;   $\mathit{best}\leftarrow w\left(S^{\star }\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 {\mathrm{E}}_{\mathrm{XACT}}{\mathrm{W}}_{\mathrm{EIGHTED}}\mathrm{IDS}\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^{\star }\leftarrow S_i$;   $\mathit{best}\leftarrow w\left(S_i\right)$ 15:     end if 16: end for 17: return$S^{\star }$

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: for v 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: return  S

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. Linear-Time Pruning

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

Algorithm 7  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 }$

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$ is individually a valid vertex cover of the cleaned graph, (b) pruning a valid cover with Algorithm 7 leaves it valid, and (c) the union of valid covers is a valid cover, since the output is then $argmin$ over the sizes of seven vertex sets each shown valid by (a)–(c), 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$ solves the exact degree-0/degree-1 auxiliary instance built from every original edge, so every original edge is represented by an auxiliary edge that is covered by construction. $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 [12] guarantees for every edge. $c_6={\mathrm{S}}_{\mathrm{OLVE}}\mathrm{VC}(G,\epsilon )$ is shown valid below.

$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 7 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$ is valid before it, too, is pruned by (b).    □

5. Approximation Ratio and Consequences for the Unique Games Conjecture

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 [8]. Algorithm 1 prunes $c_1$ (Theorem 1 shows pruning preserves validity and cannot increase size) and then returns the smallest of seven 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)$.    □

Theorem 2 holds unconditionally, for every $\epsilon$ and every graph; it does not depend on the planar forest-core machinery below at all. 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 1

(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 1 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 $c_1$–$c_5$.

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 2

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

5.7. The Empirical Conjecture for the Ensemble

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

Conjecture 1

(Universal ensemble approximation ratio). There is a constant $R^{\star }<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^{\star }\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 observed or bounded ratio never exceeds $1.61$.

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 $\mathrm{\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 1); 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-seven-candidates guarantee (Theorem 2) still applies unconditionally to every one of them.

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^{\star }<2$, then Algorithm 1 would be a polynomial-time $R^{\star }$-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 5) 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^{\star }=2-\delta$ with $\delta =2-R^{\star }>0$. Khot and Regev [7], assuming the Unique Games Conjecture [6], 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^{\star }<2$ approximation theorem on its own; establishing it for some concrete $R^{\star }<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^{\star }<2$ bound.

6. Runtime Analysis

Theorem 5.

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 seven 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 star-like instance has $O\left(m\right)$ vertices and edges (one auxiliary vertex per original edge occurrence), and the degree-0/degree-1 solver visits each auxiliary vertex once, $O(n+m)$ total (the reduction is run twice, unweighted and weighted, a constant factor).

$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 [13]. 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$.

Pruning.PruneRedundantVertices (Algorithm 7) 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$ and once more to their union, a constant number (7) of $O(n+m)$ passes.

Summing over a constant number (7) 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 4.

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 the empirical conjecture of Section 5.7 (Conjecture 1), we ran the Salvador package (v0.0.7, default $\epsilon =1$) on a reproducible two-part suite of test graphs, under Python 3.12.3 and NetworkX 3.6.1 with a fixed random seed (20260627). The suite and its driver script are distributed with the package.

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 and non-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

Exact optima are infeasible to compute at the scale of Part B, so we instead certify a provable upper bound on the approximation ratio: for each instance we compute a maximal-matching lower bound $L\le \tau \left(G\right)$ (Theorem 2’s proof) and report $\left|C\right|/L$, a conservative upper bound on $\left|C\right|/\tau \left(G\right)$ that is exact on the bipartite families, where $L=\tau \left(G\right)$ by Konig’s theorem. Table 3 reports, for ten families of large and adversarial graphs (complete bipartite graphs, crown graphs, double stars joined by a bridge, a hierarchical greedy-tie-break stress construction, random 3-, 6-, and 12-regular graphs, Barabasi–Albert scale-free graphs, sparse Erdos–Renyi graphs, and Watts–Strogatz small-world graphs), the largest instance size reached, the resulting ratio upper bound, and the wall-clock time.

Across the 28 Part B instances the ratio upper bound never exceeds $1.604$, attained on a random 12-regular graph at $n=200,000$ vertices and $m=1,200,000$ edges; since this bound is computed from a maximal-matching lower bound on a non-bipartite family, the true ratio may be smaller still. Combined with Part A, the observed or bounded ratio across all $1,746$ test graphs never exceeds $1.61$, well below the classical $7/4=1.75$ mark and substantially below the unconditional worst-case bound of 2 (Theorem 2).

7.3. Scaling Study

To check the $O(n+m)$ runtime bound of Theorem 5 empirically, we ran the ensemble on two families of doubling size—4-regular graphs and Barabasi–Albert graphs with attachment parameter 3—from $n=1,000$ up to $n=128,000$, and fit wall-clock time against $n+m$ by ordinary least squares. The fit is close to linear: $R^2=0.9945$ for the 4-regular family and $R^2=0.9968$ for the Barabasi–Albert family, consistent with the linear-time bound of Theorem 5.

8. Conclusion

We have presented the Salvador algorithm, an ensemble approximate solver for the Minimum Vertex Cover problem that runs seven independently valid linear-time heuristics and returns the smallest cover found, then prunes redundant vertices. Four of the seven candidates and the pruning pass adapt the published Hvala ensemble [8]; Salvador adds a Min-to-Min heuristic, a primal-dual 2-approximation, and a planar forest-core reduction to a weighted MIDS gadget solved by an accuracy-controlled Baker-style PTAS. 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 5)—strictly linear, not merely near-linear, because the Baker layering degenerates to its greedy baseline at $k=1$ and because every candidate, including the Min-to-Min heuristic (Remark 1), admits an amortized $O(n+m)$ bucket-queue argument.

We conjecture (Conjecture 1) a universal ratio bound $R^{\star }<2$ for the ensemble under the default call, strictly below the unconditional bound of Theorem 2. On a reproducible suite of $1,746$ test graphs (Section 7), spanning exhaustively enumerated small graphs with known optima and large adversarial graphs up to $200,000$ vertices, the observed or bounded ratio never exceeds $1.61$, well under the classical $7/4$ mark, lending empirical support to the conjecture. The theoretical consequence of this conjecture is UGC-focused rather than a direct complexity-class equality claim: if Conjecture 1 were proved for some $R^{\star }<2$, then Salvador would be a polynomial-time $R^{\star }$-approximation, and by the Khot–Regev UGC-based hardness theorem for Vertex Cover [7], such a proof would refute the Unique Games Conjecture under the standard assumption $\mathrm{P}\ne \mathrm{NP}$.

Future work includes: (i) establishing or refuting Conjecture 1, whether by a tighter structural analysis of which candidate wins on which graph class or by a large-scale computational search for adversarial instances; (ii) isolating adversarial graph families that push the ensemble ratio closest to the unconditional ceiling of 2 from Theorem 2; (iii) a tight worst-case-complexity proof for the Min-to-Min candidate (Remark 1) beyond the bucket-queue argument given here; and (iv) extending the weighted MIDS framework and the ensemble methodology to dominating set, independent set, and set cover. The implementation is freely available as the Salvador package (v0.0.7) on PyPI [11].