[Rule] VERTEX COVER to SET BASIS

[isPANN]

Source: VERTEX COVER
Target: SET BASIS
Motivation: Establishes NP-completeness of SET BASIS via polynomial-time reduction from VERTEX COVER. The reduction connects graph covering problems to set representation/compression problems, showing that finding a minimum-size collection of "basis" sets from which a given family of sets can be reconstructed via unions is computationally intractable. This result by Stockmeyer (1975) is one of the earliest NP-completeness proofs for set-theoretic problems outside the core Karp reductions.

Reference: Garey & Johnson, Computers and Intractability, SP7, p.222

GJ Source Entry

[SP7] SET BASIS
INSTANCE: Collection C of subsets of a finite set S, positive integer K≤|C|.
QUESTION: Is there a collection B of subsets of S with |B|=K such that, for each c∈C, there is a subcollection of B whose union is exactly c?
Reference: [Stockmeyer, 1975]. Transformation from VERTEX COVER.
Comment: Remains NP-complete if all c∈C have |c|≤3, but is trivial if all c∈C have |c|≤2.

Reduction Algorithm

Summary:
Given a MinimumVertexCover instance (G = (V, E), K) where G is a graph with n vertices and m edges, and K is the vertex cover size bound, construct a SetBasis instance as follows:

1. Define the ground set: S = E (the edge set of G). Each element of S is an edge of the original graph.
2. Define the collection C: For each vertex v ∈ V, define c_v = { e ∈ E : v is an endpoint of e } (the set of edges incident to v). The collection C = { c_v : v ∈ V } contains one subset per vertex.
3. Define the basis size bound: Set the basis size to K (same as the vertex cover bound).
4. Additional target sets: Include in C the set of all edges E itself (the full ground set), so that the basis must also be able to reconstruct E via union. This enforces that the basis elements collectively cover all edges.

Alternative construction (Stockmeyer's original):
The precise construction by Stockmeyer encodes the vertex cover structure into a set basis problem. The key idea is:

1. Ground set: S = E ∪ V' where V' contains auxiliary elements encoding vertex identities.
2. Collection C: For each edge e = {u, v} ∈ E, create a target set c_e = {u', v', e} containing the two vertex-identity elements and the edge element.
3. Basis size: K' = K (the vertex cover bound).
4. Correctness: A vertex cover of size K in G corresponds to K basis sets (one per cover vertex), where each basis set for vertex v contains v' and all edges incident to v. Each target set c_e = {u', v'} ∪ {e} can be reconstructed from the basis sets of u and v (at least one of which is in the cover).

Correctness argument (for the edge-incidence construction):

• (Forward) If V' ⊆ V is a vertex cover of size K, define basis B = { c_v : v ∈ V' }. For each vertex u ∈ V, the set c_u (edges incident to u) must be expressible as a union of basis sets. Since V' is a vertex cover, every edge e incident to u has at least one endpoint in V'. Thus c_u = ∪{c_v ∩ c_u : v ∈ V'} can be reconstructed if the basis elements partition appropriately.
• The exact construction details depend on Stockmeyer's original paper, which ensures the correspondence is tight.

Note: The full technical details of this reduction are from Stockmeyer's IBM Research Report (1975), which is not widely available online. The construction above captures the essential structure.

Size Overhead

Symbols:

• n = num_vertices of source graph G
• m = num_edges of source graph G

Target metric (code name)	Polynomial (using symbols above)
num_items (ground set size |S|)	num_vertices + num_edges
num_sets (collection size |C|)	num_edges
basis_size (K)	K (same as vertex cover bound)

Derivation: In Stockmeyer's construction, the ground set S contains elements for both vertices and edges (|S| = n + m). The collection C has one target set per edge (|C| = m), each of size 3 (two vertex-identity elements plus the edge element). The basis size K is preserved from the vertex cover instance.

Validation Method

• Closed-loop test: reduce source MinimumVertexCover instance to SetBasis, solve target with BruteForce (enumerate all K-subsets of candidate basis sets), extract solution, map basis sets back to vertices, verify the extracted vertices form a valid vertex cover on the original graph
• Compare with known results from literature: a triangle graph K_3 has minimum vertex cover of size 2; the reduction should produce a set basis instance with minimum basis size 2
• Verify the boundary case: all c ∈ C have |c| ≤ 3 (matching GJ's remark that the problem remains NP-complete in this case)

Example

Source instance (MinimumVertexCover):
Graph G with 5 vertices {0, 1, 2, 3, 4} and 6 edges:

• Edges: e0={0,1}, e1={0,2}, e2={1,2}, e3={1,3}, e4={2,4}, e5={3,4}
• Minimum vertex cover has size K = 3: V' = {1, 2, 3}
  • e0={0,1}: covered by 1 ✓
  • e1={0,2}: covered by 2 ✓
  • e2={1,2}: covered by 1,2 ✓
  • e3={1,3}: covered by 1,3 ✓
  • e4={2,4}: covered by 2 ✓
  • e5={3,4}: covered by 3 ✓

Constructed target instance (SetBasis) using edge-incidence construction:

• Ground set: S = E = {e0, e1, e2, e3, e4, e5} (6 elements)
• Collection C (edge-incidence sets, one per vertex):
  • c_0 = {e0, e1} (edges incident to vertex 0)
  • c_1 = {e0, e2, e3} (edges incident to vertex 1)
  • c_2 = {e1, e2, e4} (edges incident to vertex 2)
  • c_3 = {e3, e5} (edges incident to vertex 3)
  • c_4 = {e4, e5} (edges incident to vertex 4)
• Basis size K = 3

Solution mapping:
Basis B = {c_1, c_2, c_3} (corresponding to vertex cover {1, 2, 3}):

• c_1 = {e0, e2, e3}, c_2 = {e1, e2, e4}, c_3 = {e3, e5}
• Reconstruct c_0 = {e0, e1}: need e0 from c_1 and e1 from c_2. But c_1 ∪ c_2 = {e0, e1, e2, e3, e4} ⊋ c_0. The union must be exactly c_0, not a superset.

This shows the simple edge-incidence construction does not directly work for Set Basis (which requires exact union, not cover). Stockmeyer's construction uses auxiliary elements to enforce exactness.

Revised construction (with auxiliary elements per Stockmeyer):

• Ground set: S = {v'_0, v'_1, v'_2, v'_3, v'_4, e0, e1, e2, e3, e4, e5} (|S| = 11)
• Collection C (one per edge, each of size 3):
  • c_{e0} = {v'_0, v'_1, e0} (for edge {0,1})
  • c_{e1} = {v'_0, v'_2, e1} (for edge {0,2})
  • c_{e2} = {v'_1, v'_2, e2} (for edge {1,2})
  • c_{e3} = {v'_1, v'_3, e3} (for edge {1,3})
  • c_{e4} = {v'_2, v'_4, e4} (for edge {2,4})
  • c_{e5} = {v'_3, v'_4, e5} (for edge {3,4})
• Basis size K = 3

Basis B corresponding to vertex cover {1, 2, 3}:

• b_1 = {v'_1, e0, e2, e3} (vertex 1: its identity + incident edges)
• b_2 = {v'_2, e1, e2, e4} (vertex 2: its identity + incident edges)
• b_3 = {v'_3, e3, e5} (vertex 3: its identity + incident edges)

Reconstruct each c ∈ C:

• c_{e0} = {v'_0, v'_1, e0}: requires v'_0, which is not in any basis set. This means vertex 0 must also contribute. The full construction needs further refinement.

Note: The exact technical details of Stockmeyer's construction require consulting the original 1975 IBM Research Report. The construction is more intricate than the simple edge-incidence approach, using carefully designed auxiliary elements to ensure the exact-union property. The example above illustrates the general idea but the precise gadget construction may differ.

References

• [Stockmeyer, 1975]: [Stockmeyer1975] Larry J. Stockmeyer (1975). "The set basis problem is {NP}-complete". IBM Research Center.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from MinimumVertexCover to SetBasis; SetBasis is currently isolated
Non-trivial	❌ Fail	No correct, implementable algorithm is presented — both constructions are shown to fail
Correctness	⚠️ Warn	Reference (Stockmeyer 1975, GJ SP7) is verified and real, but the reduction algorithm as written does not match the cited result
Well-written	❌ Fail	Multiple issues: incorrect algorithm, broken example, wrong overhead metric names, undefined symbols

Overall: 1 passed, 2 failed, 1 warning

---

Usefulness

Pass. There is currently no reduction path from MinimumVertexCover to SetBasis in the graph (pred path MinimumVertexCover SetBasis returns no path). SetBasis is an isolated node with zero incoming or outgoing reductions, so this rule would be its first connection to the reduction graph — clearly novel and useful. The motivation section is well-written, explaining the historical significance of Stockmeyer's result and its role in connecting graph covering problems to set-theoretic problems.

Non-trivial

Fail. The issue presents two different reduction constructions, and both are shown to be incorrect in the issue's own Example section:

1. Edge-incidence construction: The issue itself demonstrates this fails because Set Basis requires exact union (not superset): "c_1 ∪ c_2 = {e0, e1, e2, e3, e4} ⊋ c_0. The union must be exactly c_0, not a superset."

2. Stockmeyer construction with auxiliary elements: The issue attempts this but again shows it fails: "c_{e0} = {v'_0, v'_1, e0}: requires v'_0, which is not in any basis set. This means vertex 0 must also contribute. The full construction needs further refinement."

The issue concludes with: "The exact technical details of this reduction are from Stockmeyer's IBM Research Report (1975), which is not widely available online... the precise gadget construction may differ." This is not an implementable step-by-step algorithm — it is an acknowledgment that the actual reduction is unknown to the author. The check is not about whether the reduction exists (it does, per Stockmeyer), but whether the issue provides a correct, non-trivial construction. It does not.

Correctness

Warn. The literature references check out:

• Stockmeyer (1975): "The Set Basis Problem Is NP-Complete," IBM Research Report RC 5431 — verified in the project bibliography (stockmeyer1975setbasis in references.bib) and confirmed via web search (IBM Research Technical Paper Search).
• Garey & Johnson, SP7, p.222: The GJ entry for Set Basis states "Transformation from VERTEX COVER" with reference to Stockmeyer 1975 — this matches the issue's claim.

However, the algorithm presented in the issue does not correctly reproduce Stockmeyer's construction. Both attempted constructions are demonstrably wrong (as shown in the issue's own example). The underlying claim (VC reduces to Set Basis) is correct per the literature, but the issue does not contain a correct implementation of that reduction. Since the reference itself is valid but the algorithm diverges from it, this is a warning rather than a failure.

Well-written

Fail. Multiple substantive issues:

1. Reduction Algorithm is incomplete and self-contradictory: The section presents two constructions, both proven wrong in the Example section. An implementable issue must contain a single, correct, step-by-step procedure. The note "the precise gadget construction may differ" is effectively a placeholder.

2. Overhead table uses wrong metric names: The table lists num_items as a target metric, but SetBasis has no num_items getter. The actual getter methods are universe_size(), num_sets(), and basis_size(). The metric should be universe_size, not num_items.

3. Overhead table references undefined variable K: The row basis_size has formula K, but K is the optimization result of the source MinimumVertexCover problem, not a getter method on it. MinimumVertexCover's size fields are num_vertices and num_edges. The overhead expression must be written in terms of source problem getters. Since this is a decision-problem reduction (VC decision: "is there a cover of size ≤ K?"), K would need to be a field of the source, but the MinimumVertexCover model in this codebase is an optimization problem without an explicit K parameter.

4. Example is not fully worked: The example explicitly fails to demonstrate the reduction. It shows two attempts, both of which break down, and concludes without a working solution mapping. A valid example must show: source instance → complete reduction construction → target instance → solve target → extract solution → verify on source.

5. Solution extraction is undefined: There is no clear description of how to map a SetBasis solution back to a MinimumVertexCover solution. The "Solution mapping" subsection attempts this but fails because the construction itself is wrong.

6. Inconsistent construction between sections: The Reduction Algorithm section describes |S| = n + m and |C| = m, but the Example section uses a different construction with |S| = 6 (edges only) and |C| = 5 (one per vertex). These don't match.

7. Symbol K undefined in source context: The overhead table and algorithm reference K as "the vertex cover bound," but MinimumVertexCover is an optimization problem — there is no explicit K parameter in the source model's schema.

Recommendations

• Consult the original Stockmeyer 1975 report (IBM RC 5431) to obtain the precise reduction construction. The report may be available through IBM's technical report archives or through interlibrary loan.
• Consider an alternative source: The reduction from Vertex Cover to Set Basis may also appear in survey papers on set-theoretic NP-complete problems. A more accessible description might exist in textbooks beyond GJ.
• If the original construction cannot be found, consider whether a correct construction can be derived from first principles. The key challenge is the "exact union" requirement — basis sets that are subsets of the target can be included, and their union must equal the target exactly.
• Fix the overhead expressions to use the correct getter names: universe_size instead of num_items, and express basis_size in terms of source problem parameters (num_vertices, num_edges).