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 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.6)—that, on every instance we have tested under the default call $\epsilon =0.1$, produces a vertex cover whose size never exceeds $7/4=2-1/4$ of the known optimum, a bound attained by an explicit bipartite witness. The algorithm, called FindVertexCover, 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.

Reduction and kernel solve. The core routine SolveVC reduces the cleaned graph G to a weighted MIDS instance on a planar forest-core gadget H and solves H with an accuracy-controlled Baker-style PTAS [8] of layering width $k=\lceil 1/\epsilon \rceil$. All non-core edges are then covered by a greedy repair step.

3.

Linear-time pruning.PruneRedundantVertices makes a single forward pass over the candidate cover C and removes every vertex all of whose neighbours are already covered, reducing $\left|C\right|$ without compromising validity.

For any fixed $\epsilon$ all phases are bounded by $O(1/\epsilon )$ passes over vertices and edges, giving an overall complexity of $O\left((n+m)/\epsilon \right)$, where $n=\left|V\right|$ and $m=\left|E\right|$; this is near-linear for fixed $\epsilon$.

Contributions

The main contributions of this paper are:

• A practical vertex-cover algorithm with a linear planar forest-core reduction and an accuracy-controlled Baker-style weighted MIDS solver, running in $O\left(\right(n+m)/\epsilon )$ time (near-linear for fixed $\epsilon$).
• A weighted MIDS gadget that encodes the planar forest core as a minimum-weight independent dominating set instance; because the gadget is itself a forest, the Baker PTAS solves it (near-)exactly, so the decoded set is a (near-)minimum cover of the core.
• A reproducible experiment, stored in the car/ folder, that computes exact optima without MILP and evaluates the default call $\epsilon =0.1$ on the graph atlas, bipartite families, grids, and random general graphs.
• An empirical conjecture that the universal approximation ratio under the default call is at most $7/4=2-1/4$. Across $1,718$ feasible graphs the maximum ratio is exactly $7/4$ (an explicit eleven-vertex bipartite witness) and no instance exceeds it, so the conjectured bound is tight.
• A conditional UGC consequence: under $\mathrm{P}\ne \mathrm{NP}$, any proof of a universal $7/4$ ratio for this polynomial-time algorithm would refute the Unique Games Conjecture via the Khot–Regev hardness theorem.
• An open-source implementation, Salvador v0.0.6, in which the accuracy parameter $\epsilon$ drives the Baker PTAS.

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 the experimental results. Section 8 concludes.

2. Research Data

The algorithm is implemented in the Python package Salvador, freely available on the Python Package Index [9]. The current version is v0.0.6; the accuracy parameter $\epsilon$ drives the Baker PTAS layering (Remark 1). Code metadata is summarised in Table 1, and the local reduction gadget is depicted in Figure 1.

3. Description of the Algorithm

We present the pseudocode for the three components of the Salvador algorithm.

3.1. Main Algorithm

Algorithm 1 is the entry point. After cleaning the graph it delegates to SolveVC and then applies the pruning pass.

Algorithm 1 FindVertexCover$(G,\epsilon )$

Require:  Undirected graph $G=(V,E)$, accuracy parameter $\epsilon \in (0,1]$ (default $\epsilon =0.1$; smaller $\epsilon$ gives a more thorough solve, see Remark 1) 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$ then return ∅ 4: end if 5: $C,\_\leftarrow$SolveVC(G,ε) 6: $\mathit{adj}\leftarrow \{v\mapsto N_G\left(v\right):v\in V\}$ 7: $C\leftarrow$PruneRedundantVertices(adj, C) 8: return C

3.2. Weighted MIDS Gadget and Planar Solve

Algorithm 2 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 2 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: return C

The pass BakerPtasWeightedIDS (Algorithm 3) 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 4 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 1 

(On the accuracy parameter $\epsilon$). The public entry pointfind_vertex_coverfixes the default $\epsilon =0.1$, which is the configuration analysed throughout this paper. The parameter controls the Baker layering width $k=\lceil 1/\epsilon \rceil$; $\epsilon \ge 1$ ($k=1$) reduces to the greedy maximal-independent-set baseline of Algorithm 4. The gadget construction is itself ε-independent; ε enters only the IDS pass. The returned cover depends on ε through the layer choices, and on the vertex ordering through the spanning-forest construction, so it is sensitive to both. As Section 7 reports, some hard bipartite instances are solved optimally under one labelling yet incur a positive gap under a permuted labelling. All claims below refer to the default call $\epsilon =0.1$ on the canonical (sorted) labelling used by the experiment.

Algorithm 3 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 4:GreedyWeightedMIS$\left(H\right)$ — $k=1$ baseline

Require:  Weighted gadget H with vertex weights $w\left(·\right)\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: return S

Figure 1 shows the local gadget introduced for each core edge $(u,v)\in E\left(G_p\right)$ in Algorithm 2. 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.3. Linear-Time Pruning

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

Algorithm 5 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.

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 $C=\{v:(v,0)\in S\}$, ensuring all core edges are covered.

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 C valid for $G_p$. Every edge in $E\setminus E_p$ is inspected in the repair loop: if neither endpoint is in C, the higher-degree endpoint is added. After the loop every edge of E has at least one endpoint in C.

Pruning. A vertex $v\in C$ is removed by Algorithm 5 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.    □

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, let H be the weighted MIDS gadget of Algorithm 2, and set ${\tau }_p^{*}=\tau \left(G_p\right)$.

5.2. Gadget Cost Identity

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 2 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$; both are bounded experimentally in Section 7.

5.3. Elementary Bounds

Proposition 1 

(Elementary bounds). For every graph G with n vertices and m edges, the cover C returned by Algorithm 1 satisfies $\left|C\right|\le min\{n,m\}$ and is a valid vertex cover. Consequently $\left|C\right|/\tau \left(G\right)\le n/\tau \left(G\right)$, which is finite but not a constant in general.

Proof. 

Validity is Theorem 1. 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 $\left|C\right|\le n$ and $\left|C\right|\le \left|\mathrm{core}\mathrm{cover}\right|+m$; pruning only removes vertices.    □

5.4. Linear Core Guarantee

Theorem 2 

(Core cover guarantee). For any input graph G, Algorithm 2 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.5. 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, Algorithm 1 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 C and otherwise adds exactly one endpoint. Thus the number of repair additions is at most $|E\setminus E_p|$.    □

In practice the 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$. The experimental data in Section 7 confirms that the default call consistently achieves ratios well below $7/4$.

5.6. A Lower Bound and the $7/4$ Hypothesis

The exact experiments force a lower bound on the worst-case ratio of the default call that matches the conjectured upper bound.

Proposition 3 

(A lower bound of $7/4$ on the worst-case ratio). There is an explicit bipartite graph on which Algorithm 1 with $\epsilon =0.1$ returns a cover of size 7 while $\tau \left(G\right)=4$, so the worst-case approximation ratio of the default call is at least $7/4$. No approximation factor smaller than $7/4$ can hold for this configuration.

Proof. 

Take G on vertices $\{0,\dots ,10\}$ with edge set

$$\begin{array}{cc}\hfill \{& (0,7),(0,8),(0,9),(0,10),(1,7),(1,8),(1,9),(1,10),\hfill \\ & (3,7),(3,8),(3,9),(3,10),(4,7),(4,9),(4,10),(5,7),(5,8),(5,9)\}.\hfill \end{array}$$

All edges run between $\{0,1,3,4,5\}$ and $\{7,8,9,10\}$, so G is bipartite, and $\{7,8,9,10\}$ is a cover of size 4; a maximum matching has size 4, so by Konig’s theorem $\tau \left(G\right)=4$, certified without MILP. At $\epsilon =0.1$ the algorithm returns a cover of size 7, so the ratio is $7/4$. The instance is stored verbatim in the car/ results.    □

We state the matching empirical upper-bound hypothesis below.

Conjecture 1 

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

$$\left|C\right|\le \frac{7}{4}\tau \left(G\right)=(2-\frac{1}{4})\tau \left(G\right).$$

Conjecture 1 is not a theorem. It is motivated by the reproducible experiment in Section 7, where, across $1,718$ feasible graphs with exact optima, the maximum ratio is exactly $7/4$ and no instance exceeds it. Together with Proposition 3, this makes the conjectured bound tight: a witness attains $7/4$, so the worst-case ratio of the default call is conjectured to be exactly $7/4$. The threshold $7/4=2-1/4$ lies strictly below the UGC threshold of 2, with margin $\delta =1/4>0$.

5.7. Why the $7/4$ Ceiling Holds Across Graph Classes

The behaviour under the default call rests on two mechanisms in series. First, because the gadget H built from the forest core is itself a forest, the per-component tree dynamic program is exact, so the decoded set is a near-minimum vertex cover of the core $G_p$ (Lemma 1); the residual loss is the layering slack plus the greedy repair of the non-core edges $E\setminus E_p$. Second, the final redundancy-pruning pass deletes any vertex all of whose incident edges are already covered. Across natural families the core solve already covers almost all edges, so the ratio stays at or near 1; it inflates only on graphs where many non-core edges survive the core solve at the default layering, and even then it never exceeded $7/4$. We survey the main classes below; Table 2 summarises them.

Classes solved optimally.

On stars $K_{1,k}$ the 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. The experiment reports ratio 1 on every path, cycle, clique, star, complete-bipartite, wheel, grid, and barbell instance tested.

Dense and degree-heterogeneous classes.

Complete graphs$K_n$ have $\tau =n-1$; the spanning-tree core is solved and the dense non-core edges are absorbed, returning the optimal $(n-1)$-cover. Wheels$W_n$, barbell and lollipop graphs concentrate their optima on hub or clique vertices captured by the core solve, and chordal and interval graphs on simplicial hubs. Random general graphs ($n\le 12$) stay at mean ratio near 1 with maximum $5/4$.

Bipartite and planar classes: the stress region.

For bipartite graphs Konig’s theorem makes $\tau$ equal to the maximum matching, which is also how we certify the optima here. These are the graphs that most stress the default call: when many edges fall outside the spanning-forest core, the default layering ($k=10$) can decode a core cover whose non-core repair overshoots. Random bipartite graphs reached $3/2$, and a bipartite hill-climbing search reached $7/4$, producing the extremal witness of Proposition 3. Grids and other bounded-treewidth planar families are milder, topping out at $4/3$, because 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.

The hard witness, and why it stops exactly at $7/4$.

The extremal instance of Proposition 3 is an eleven-vertex bipartite graph on which the default call returns 7 against optimum 4, ratio $7/4$. A relabel and edge-order stress sweep of a smaller seven-vertex bipartite obstruction reaches $5/3$, and the exhaustive graph atlas through seven vertices ($1,245$ graphs) tops out at $4/3$. No tested instance exceeded $7/4$, and one attains it, so Conjecture 1 is tight: the $7/4=2-1/4$ ceiling coincides with the proven worst case (Proposition 3) and lies strictly below the UGC threshold 2. The ratio is sensitive to vertex ordering—the seven-vertex obstruction is solved optimally under its canonical labelling yet reaches $5/3$ under permutations—so the worst case reflects the interaction of the default layering with the input ordering rather than an intrinsic limit of the gadget.

5.8. Conditional Consequence for the Unique Games Conjecture

Theorem 3 

(UGC consequence of a universal $7/4$ bound). If Conjecture 1 were proved, then Algorithm 1 would be a polynomial-time $7/4$-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 4) gives polynomial, indeed near-linear, time for the default fixed $\epsilon =0.1$. A proof of Conjecture 1 would therefore give a polynomial-time approximation ratio $7/4=2-\delta$ with $\delta =1/4>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 2. 

Theorem 3 is conditional. The experiment neither disproves UGC nor proves a $7/4$ approximation theorem; its role is to sharpen the research question. The empirical evidence is compatible with a constant $(2-\delta )$ phenomenon with $\delta =1/4$; the largest observed ratio is exactly $7/4$, so the conjectured bound is tight rather than conservative, and any single instance above $7/4$ would refute it.

6. Runtime Analysis

Theorem 4. 

For a fixed accuracy $\epsilon \in (0,1]$, Algorithm 1 runs in worst-case time $O\left((n+m)\left(\alpha \left(n\right)+1/\epsilon \right)\right)$, where $n=\left|V\right|$, $m=\left|E\right|$, and α is the inverse Ackermann function. For the default $\epsilon =0.1$ this is near-linear.

Proof. 

We bound each phase.

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)$.

Spanning-forest core.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 a sequence of m operations on n elements costs $O\left((n+m)\alpha \left(n\right)\right)$ in the worst case, tight for path-compression heuristics [10].

Gadget size. 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.

Baker PTAS pass.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; since H is a forest, this DP runs in time linear in the component size, so one shift costs $O\left(\right|V\left(H\right)|+|E\left(H\right)\left|\right)=O\left(n\right)$. The greedy repair of the removed slab and the validity/weight checks are also $O\left(n\right)$ per shift. Over k shifts the pass costs $O\left(kn\right)=O(n/\epsilon )$. Decoding the cover is $O\left(n\right)$.

Repair and pruning. The two 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, costing $O(n+m)$. PruneRedundantVertices 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)$.

Summing, the union-find pass contributes $O\left(\right(n+m\left)\alpha \right(n\left)\right)$ and the Baker pass contributes $O(n/\epsilon )$; all other phases are $O(n+m)$. The total is $O\left((n+m)\left(\alpha \right(n)+1/\epsilon )\right)$, near-linear for fixed $\epsilon$.    □

Remark 3. 

Because the gadget H 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. The $\alpha \left(n\right)$ union-find factor can likewise be removed by building the spanning-forest core with a depth-first traversal, yielding a strictly $O(n/\epsilon )$ algorithm if desired.

7. Reproducible Experiment

The repository ships the reproducibility suite in the car/ folder, which records, for every tested graph, the cover returned by the default call, the exact optimum, the ratio, and a validity flag, together with the family-level summary of Table 3.

The experiment avoids MILP entirely. For every tested graph the optimum is computed exactly: on bipartite instances by maximum matching and Konig’s theorem, and otherwise by a deterministic branch-and-bound maximum-independent-set solver via

$$\tau \left(G\right)=\left|V\right(G\left)\right|-\alpha \left(G\right).$$

The candidate solver is salvador.algorithm.find_vertex_cover under the default call $\epsilon =0.1$, and the reported ratio for a graph is $\left|C\right|/\tau \left(G\right)$.

The suite has the following components: (i) the NetworkX graph atlas, i.e., all nonempty graphs on $2\le n\le 7$ vertices; (ii) an explicit seven-vertex bipartite obstruction together with a relabel/edge-order stress sweep of it; (iii) random bipartite graphs and a bipartite hill-climbing search, the latter producing the extremal witness of Proposition 3; (iv) bipartite grids; and (v) random general graphs for $n\le 12$. In total the run considers $1,718$ feasible graphs, all of which receive valid covers.

Table 3 reports the results. The maximum ratio anywhere is exactly $7/4$, attained by the eleven-vertex bipartite hill-climb witness of Proposition 3; no instance exceeds $7/4$. The seven-vertex obstruction is solved optimally under its canonical (sorted) labelling, giving ratio 1, while its relabelled and edge-order variants reach $5/3$; this illustrates that the gap is driven by the interaction of the default layering with the input ordering.

The takeaway from Table 3 is that across $1,718$ feasible graphs with exact optima the default-call ratio never exceeds $7/4$, with one witness attaining it. This does not prove Conjecture 1; it provides the empirical evidence that motivates the UGC-relevant $7/4$ formulation of Theorem 3, and, since the bound is attained, shows it cannot be tightened for this configuration. Should a future run exhibit a graph whose default-call ratio exceeds $7/4$, the conjecture would have to be revised, exactly as the experiment is designed to detect.

8. Conclusion

We have presented the Salvador algorithm, an approximate solver for the Minimum Vertex Cover problem that combines a weighted MIDS gadget construction with an accuracy-controlled Baker-style PTAS and a redundancy-pruning step. The algorithm always returns a valid vertex cover (Theorem 1) and runs in near-linear time for any fixed accuracy $\epsilon$ (Theorem 4).

Because the gadget built from the forest core is itself a forest, the per-component tree dynamic program is exact, so the decoded set is a near-minimum cover of the core and the residual loss is the layering slack plus the repair of non-core edges. Under the default call $\epsilon =0.1$, across $1,718$ feasible graphs with exact optima, the ratio never exceeds $7/4$, a value attained by an explicit eleven-vertex bipartite witness. This motivates Conjecture 1: a universal $7/4$ approximation hypothesis. Proposition 3 proves a matching $7/4$ lower bound, so the conjectured ceiling is tight for this configuration.

The theoretical consequence is UGC-focused rather than a direct complexity-class equality claim. If Conjecture 1 were proved, then Salvador would be a polynomial-time $2-\delta$ approximation with $\delta =1/4>0$. 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 through structural analysis of the non-core repair step; (ii) understanding the parameter sensitivity that makes the default $\epsilon =0.1$ overshoot where larger $\epsilon$ recovers the optimum; (iii) isolating graph families that force the largest residual repair; and (iv) extending the weighted MIDS framework to dominating set, independent set, and set cover. The implementation is freely available as the Salvador package (v0.0.6) on PyPI [9].