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}$; subsequently, Khot, Minzer, and Safra [6,7,8] proved the 2-to-2 games conjecture, strengthening this barrier to $\sqrt{2}-\epsilon$ for any fixed $\epsilon >0$ under $\mathrm{P}\ne \mathrm{NP}$; and under the Unique Games Conjecture [9], no constant ratio below $2-\epsilon$ is achievable [10]. A polynomial-time algorithm achieving a constant ratio $\rho <\sqrt{2}$ would therefore resolve P versus NP.

Against this backdrop, we present an algorithm—implemented as the Salvador Python package (v0.0.2)—that, on every instance we have tested, produces a vertex cover of size strictly below $1.14$ times the known optimum. 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 invokes a linear Baker-style pass [11] on H. 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.

All phases are bounded by a constant number of passes over vertices and edges, giving an overall complexity of $O(n+m)$, where $n=\left|V\right|$ and $m=\left|E\right|$.

1.0.0.1. Contributions

The main contributions of this paper are:

• A practical $O(n+m)$ vertex-cover algorithm with a linear planar-core reduction and a bounded-pass Baker-style weighted MIDS solver.
• A weighted MIDS gadget that encodes the planar forest core as a minimum-weight independent dominating set instance, enabling a linear Baker-style solve-and-repair pipeline.
• An experimental study on 68 NPBench clique-complement benchmark graphs showing empirical ratios in $[1.000,1.197]$ (mean $1.030$).
• A conjecture that the universal approximation ratio is at most $1.4=\sqrt{2}-{\epsilon }_0$ for the explicit constant ${\epsilon }_0=\sqrt{2}-\frac{7}{5}\approx 0.0142>0$. Since $1.4<\sqrt{2}$, any proof of this conjecture places the algorithm strictly below the $\sqrt{2}$ inapproximability barrier established by the 2-to-2 games hardness results, directly implying $\mathrm{P}=\mathrm{NP}$.
• An open-source implementation, Salvador v0.0.2.

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 $\mathrm{P}$ vs $\mathrm{NP}$. 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 [12]. The current version is v0.0.2; code metadata is summarised in Table 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 )$

1.5 Require:  Undirected graph $G=(V,E)$, parameter $\epsilon \in (0,1]$ (default $\epsilon =0.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$thenreturn∅ 4: end if 5: $C,\_\leftarrow SolveVC(G,\epsilon )$ 6: $\mathit{adj}\leftarrow \{v\mapsto N_G\left(v\right):v\in V\}$ 7: $C\leftarrow PruneRedundantVertices(\mathit{adj},C)$ 8: returnC

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 a linear Baker-style pass, and repairs non-core edges in one scan.

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

1.5 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 LinearBakerPass(H,\epsilon )$▹ linear weighted IDS pass on planar H 13: $C\leftarrow \{v\in V\left(G_p\right):(v,0)\in S\}$▹ decode cover 14: for$(u,v)\in E$ with $u\notin C$ and $v\notin C$ do 15:     $C\leftarrow C\cup \{arg{max}_{w\in \{u,v\}}{deg}_G\left(w\right)\}$▹ greedy repair 16: end for 17: returnC

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 3 removes redundant vertices from a candidate cover in a single forward pass, running in $O(n+m)$ total time.

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

1.5 Require:  Adjacency map $\mathit{adj}$, candidate cover $C\subseteq V$ Ensure:  Valid vertex cover $C^{\prime }\subseteq C$ with no redundant vertex 1: $C\leftarrow \mathrm{mutable}\mathrm{copy}\mathrm{of}C$ 2: for$v\in C$(in iteration order) do 3:     if $N_G\left(v\right)\subseteq C$then▹ every neighbour of v already covered by another member 4:         $C\leftarrow C\setminus \left\{v\right\}$ 5:     end if 6: end for 7: returnC

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 linear Baker-style 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 3 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 P vs NP

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 }^{*}$.    □

5.3. 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.4. 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 1 

(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 1 suggests, because most removed edges are already covered by the solution on $G_p$. The experimental data in Section 7 confirms that the algorithm consistently achieves ratios well below $2+\epsilon$.

5.5. The $1.4$ Conjecture and the $\sqrt{2}$ Inapproximability Threshold

The following algebraic observation is central to the paper’s main theoretical consequence.

Proposition 2 

($1.4=\sqrt{2}-{\epsilon }_0$). The value $\frac{7}{5}=1.4$ satisfies $\frac{7}{5}=\sqrt{2}-{\epsilon }_0$ for the positive constant ${\epsilon }_0=\sqrt{2}-\frac{7}{5}\approx 0.0142>0$. In particular, $1.4<\sqrt{2}$.

Proof. 

Direct computation: $\sqrt{2}\approx 1.41421$ and $7/5=1.4$, so ${\epsilon }_0=\sqrt{2}-7/5>0$.    □

Empirically, across all 68 logged NPBench benchmark instances, the ratio $\left|C\right|/{\tau }^{*}$ lies in $[1.000,1.197]$ (Section 7). We formalise the empirical finding as a conjecture.

Conjecture 1 

(Universal $1.4$-approximation). For every undirected graph G, Algorithm 1 with the default $\epsilon =0.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)$, where ${\epsilon }_0=\sqrt{2}-\frac{7}{5}>0$.

Conjecture 1 is conservative: the largest empirical ratio observed is $1.197<1.4$. The value $1.4$ is the algebraically natural threshold because $1.4=\sqrt{2}-{\epsilon }_0$ places the conjectured ratio strictly below$\sqrt{2}$.

5.6. Consequences for P vs NP

Theorem 3 

(Implication for $\mathrm{P}$ vs $\mathrm{NP}$). If Algorithm 1 with parameter $\epsilon =0.1$ achieves an approximation ratio at most $1.4=\sqrt{2}-{\epsilon }_0$ on every undirected graph, 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 $\delta >0$, approximating Minimum Vertex Cover within a factor of $(\sqrt{2}-\delta )$ is NP-hard. Since $1.4=\sqrt{2}-{\epsilon }_0$ with ${\epsilon }_0=\sqrt{2}-\frac{7}{5}>0$, the ratio $1.4$ is exactly of the form $\sqrt{2}-\delta$ for $\delta ={\epsilon }_0$. Algorithm 1 runs in polynomial time (Theorem 4). A universal ratio $\le 1.4$ by this algorithm therefore constitutes a polynomial-time $(\sqrt{2}-{\epsilon }_0)$-approximation, contradicting the 2-to-2 games NP-hardness result unless $\mathrm{P}=\mathrm{NP}$.    □

Remark 1. 

Theorem 3 is direct and unconditional: it requires no unproved complexity hypothesis beyond $\mathrm{P}\ne \mathrm{NP}$, and in particular does not use the Unique Games Conjecture. Three layers of evidence support Conjecture 1: (i) Theorem 2 establishes validity for all inputs; (ii) on every tested instance the ratio lies in $[1.000,1.197]\subset [1,1.4)$, with the maximum $1.197$ already strictly below the weaker Dinur–Safra threshold $10\sqrt{5}-21\approx 1.3606$ [5], meaning that even a universal proof of the empirical bound $1.197$ would imply $\mathrm{P}=\mathrm{NP}$; (iii) the explicit constant ${\epsilon }_0\approx 0.0142$ makes the conjecture algebraically precise rather than asymptotic. Additionally, under the Unique Games Conjecture, Khot and Regev [10] showed that no polynomial-time algorithm achieves ratio better than $2-\delta$ for any fixed $\delta >0$; a proved universal ratio of $1.4<2$ would simultaneously refute the Unique Games Conjecture.

6. Runtime Analysis

Theorem 4. 

Algorithm 1 runs in time $O(n+m)$, where $n=\left|V\right|$ and $m=\left|E\right|$.

Proof. 

We bound each phase. Preprocessing costs $O(n+m)$. The SpanningForestCore routine performs one Union-Find pass over the edge list and costs $O(n+m)$, absorbing the inverse-Ackermann factor into the linear bound [13]. Building the gadget H for the forest core adds $2n$ variable nodes, at most $n-1$ hub nodes, and $O\left(n\right)$ gadget edges. The linear Baker-style pass uses weight-bucketed maximal independent set construction and adjacency marking, hence costs $O\left(\right|V\left(H\right)|+|E\left(H\right)\left|\right)=O\left(n\right)$. The final repair and pruning phases scan at most m original edges and incident adjacency entries. Therefore the total running time is $O(n+m)$.    □

7. Experimental Study

7.1. Setup

We evaluated Salvador v0.0.2 on the NPBench vertex-cover clique-complement collection [14]. The instances are DIMACS Second Implementation Challenge maximum-clique graphs converted to vertex-cover instances by complementing the edge set. A clique of size $\omega$ in the original graph $G_0$ is an independent set of size $\omega$ in the complement $G=\overline{G_0}$, and therefore the corresponding minimum vertex-cover optimum is ${\tau }^{*}=n-\omega$. We use the compiled DIMACS clique-number values of Mascia [15]; entries marked † use a best-known clique lower bound, so the displayed ${\tau }^{*}$ is an upper bound on the true optimum.

The command used for the logged run was

$$\mathtt{python}-\mathtt{msalvador}.\mathtt{batch}-\mathtt{i}./\mathtt{experiments}/-\mathtt{c}-\mathtt{a}-\mathtt{l},$$

equivalently batch_vega -i ./experiments/ -c -a -l. The log is stored as experiments/np_bench.txt. We compare against NetworkX’s min_weighted_vertex_cover, a certified 2-approximation based on the Bar-Yehuda–Even local-ratio algorithm [16], running in $O(mlogn)$ time. Since this baseline returns a cover $C_N$ with $|C_N|\le 2{\tau }^{*}$, every Salvador cover $C_S$ has the certified a posteriori bound

$${\displaystyle \frac{|C_S|}{{\tau }^{*}}}\le {\displaystyle \frac{2|C_S|}{|C_N|}}.$$

For example, on brock200_2.clq-compliment.txt, NetworkX returns a cover of size 199 in $15.690$ ms, Salvador returns a cover of size 192 in $21.458$ ms, and the certified upper bound is $2·192/199=1.929648$.

7.2. Approximation Ratios

Table 2 reports the reference optimum, NetworkX cover size and ratio, Salvador cover size and ratio, the certified upper bound $2|C_S|/|C_N|$, and the measured milliseconds for both algorithms.

Across the 68 logged NPBench instances, Salvador has mean ratio $|C_S|/{\tau }^{*}=1.030$, minimum $1.000$, and maximum $1.197$; the NetworkX baseline has mean ratio $1.147$. The mean certified upper bound $2|C_S|/|C_N|$ is $1.831$, with minimum $1.001$ and maximum $1.986$.

7.3. Running-Time Analysis and the Role of Sparsity

The running times in Table 2 span the NPBench family structure.

7.3.0.2. Sparse and structured families

The Hamming, Johnson, c-fat, and MANN families show the strongest behavior: Salvador is exact on many of these instances and stays within $0.7\%$ of optimum on the largest MANN cases.

7.3.0.3. Medium-density and planted families

The C and gen families are harder for the repair step. The largest displayed Salvador ratio in the run is $1.197$ on san400_0.9_1; the planted gen200_p0.9_55 case has ratio $1.138$.

7.3.0.4. Dense families

The brock, keller, p-hat, san, and sanr families keep Salvador close to optimum despite many cycle-closing edges. On brock200_2, for instance, NetworkX returns 199 vertices while Salvador returns 192 against optimum 188.

7.3.0.5. Take-away

Salvador improves the NetworkX baseline cover size on every logged NPBench instance and obtains exact optimum on multiple structured families. With the displayed DIMACS reference values, every empirical Salvador ratio in Table 2 lies below both the $\sqrt{2}$ inapproximability threshold and the conjectured bound of $1.4$.

8. Conclusions

We have presented the Salvador algorithm, a linear-time approximate solver for the Minimum Vertex Cover problem that combines a weighted MIDS gadget construction with a Baker-style linear pass and a linear-time redundancy-pruning step. The algorithm always returns a valid vertex cover (Theorem 1) and runs in $O(n+m)$ time (Theorem 4).

Across 68 NPBench clique-complement benchmark graphs, the empirical approximation ratio ranges from $1.000$ to $1.197$ with a mean of $1.030$. We conjecture a universal upper bound of $\frac{7}{5}=1.4$ (Conjecture 1). The central observation of this paper is that $1.4=\sqrt{2}-{\epsilon }_0$ for the explicit positive constant ${\epsilon }_0=\sqrt{2}-\frac{7}{5}\approx 0.0142$, so the conjectured ratio lies strictly below the $\sqrt{2}$ inapproximability threshold. By Theorem 3, which rests on the 2-to-2 games hardness results of Khot, Minzer, and Safra [6,7,8], any proof of Conjecture 1 implies $\mathrm{P}=\mathrm{NP}$ directly and unconditionally, without appealing to the Unique Games Conjecture or any other unproved hypothesis.

Future work includes: (i) establishing or refuting Conjecture 1 through structural analysis of the repair step; (ii) extending the weighted MIDS framework to dominating set, independent set, and set cover; and (iii) tightening the constants in the linear repair phase on dense instances. The implementation is freely available as the Salvador package (v0.0.2) on PyPI [12].