[Rule] MinimumVertexCover to ShortestCommonSupersequence

[isPANN]

Source: MinimumVertexCover
Target: ShortestCommonSupersequence
Motivation: Establishes NP-completeness of SHORTEST COMMON SUPERSEQUENCE via polynomial-time reduction from VERTEX COVER. The SCS problem asks for the shortest string containing each input string as a subsequence. Maier (1978) showed this is NP-complete even for alphabets of size 5 by encoding the "at least one endpoint" constraint of vertex cover through subsequence containment requirements.

Reference: Garey & Johnson, Computers and Intractability, SR8, p.228. [Maier, 1978].

GJ Source Entry

[SR8] SHORTEST COMMON SUPERSEQUENCE
INSTANCE: Finite alphabet Σ, finite set R of strings from Σ*, and a positive integer K.
QUESTION: Is there a string w ∈ Σ* with |w| ≤ K such that each string x ∈ R is a subsequence of w?
Reference: [Maier, 1978]. Transformation from VERTEX COVER.
Comment: Remains NP-complete even if |Σ| = 5. Solvable in polynomial time if |R| = 2 (by first computing the longest common subsequence) or if all x ∈ R have |x| ≤ 2.

Reduction Algorithm

Summary:
Given a VERTEX COVER instance G = (V, E) with V = {v_1, ..., v_n}, E = {e_1, ..., e_m}, and integer K, construct a SHORTEST COMMON SUPERSEQUENCE instance as follows (based on Maier's 1978 construction):

1. Alphabet: Σ = {v_1, v_2, ..., v_n} ∪ {#} where # is a separator symbol not in V. The alphabet has |V| + 1 symbols. (For the fixed-alphabet variant with |Σ| = 5, a further encoding step is applied.)

2. String construction: For each edge e_j = {v_a, v_b} (with a < b), create the string:
   s_j = v_a · v_b
   This string of length 2 encodes the constraint that in any supersequence, the symbols v_a and v_b must both appear (at least one needs to be "shared" across edges).

3. Vertex-ordering string: Create a "backbone" string:
   T = v_1 · v_2 · ... · v_n
   This ensures the supersequence respects the vertex ordering.

4. Additional constraint strings: For each pair of adjacent vertices in an edge, separator-delimited strings enforce that the vertex symbols appear in specific positions. The full construction uses the separator # to create blocks so that the supersequence can be divided into n blocks, where each block corresponds to a vertex. A vertex is "selected" (in the cover) if its block contains the vertex symbol plus extra copies needed by incident edges; a vertex not in the cover has its symbol appear only once.

5. Bound: K' = n + m - K, where n = |V|, m = |E|, K = vertex cover size bound. (The exact formula depends on the padding used in the construction.)

6. Correctness (forward): If G has a vertex cover S of size ≤ K, the supersequence is constructed by placing all vertex symbols in order, and for each edge e = {v_a, v_b}, the subsequence v_a · v_b is embedded by having both symbols present. Because S covers all edges, at most K vertices carry extra "load," keeping the total length within K'.

7. Correctness (reverse): If a supersequence w of length ≤ K' exists, the vertex symbols that appear in positions accommodating multiple edge-strings correspond to a vertex cover of G with size ≤ K.

Key insight: Subsequence containment allows encoding the "at least one endpoint must be selected" constraint. The supersequence must "schedule" vertex symbols so that every edge-string is a subsequence, and minimizing the supersequence length corresponds to minimizing the vertex cover.

Time complexity of reduction: O(n + m) to construct the instance.

Size Overhead

Symbols:

• n = num_vertices of source VertexCover instance (|V|)
• m = num_edges of source VertexCover instance (|E|)
• K = vertex cover bound

Target metric (code name)	Polynomial (using symbols above)
alphabet_size	num_vertices + 1
num_strings	num_edges + 1
max_string_length	num_vertices
bound_K	num_vertices + num_edges - cover_bound

Derivation: One symbol per vertex plus separator; one string per edge plus one backbone string; bound relates linearly to n, m, and K.

Validation Method

• Closed-loop test: reduce a MinimumVertexCover instance to ShortestCommonSupersequence, solve target with BruteForce (enumerate candidate supersequences up to length K'), extract solution, verify on source
• Test with known YES instance: triangle graph K_3, vertex cover of size 2
• Test with known NO instance: star graph K_{1,5}, vertex cover must include center vertex
• Verify that every constructed edge-string is indeed a subsequence of the constructed supersequence
• Compare with known results from literature

Example

Source instance (MinimumVertexCover):
Graph G with 6 vertices V = {v_1, v_2, v_3, v_4, v_5, v_6} and 7 edges:

• Edges: {v_1,v_2}, {v_1,v_3}, {v_2,v_3}, {v_3,v_4}, {v_4,v_5}, {v_4,v_6}, {v_5,v_6}
• (Triangle v_1-v_2-v_3 connected to triangle v_4-v_5-v_6 via edge {v_3,v_4})
• Vertex cover of size K = 3: {v_2, v_3, v_4} covers all edges. Check:
  • {v_1,v_2}: v_2 ✓; {v_1,v_3}: v_3 ✓; {v_2,v_3}: v_2 ✓; {v_3,v_4}: v_3 ✓; {v_4,v_5}: v_4 ✓; {v_4,v_6}: v_4 ✓; {v_5,v_6}: needs v_5 or v_6 -- FAIL.
• Correct cover of size K = 4: {v_1, v_3, v_4, v_6} covers all edges:
  • {v_1,v_2}: v_1 ✓; {v_1,v_3}: v_1 ✓; {v_2,v_3}: v_3 ✓; {v_3,v_4}: v_3 ✓; {v_4,v_5}: v_4 ✓; {v_4,v_6}: v_4 ✓; {v_5,v_6}: v_6 ✓.

Constructed target instance (ShortestCommonSupersequence):

• Alphabet: Σ = {v_1, v_2, v_3, v_4, v_5, v_6, #}
• Strings (one per edge): R = {v_1v_2, v_1v_3, v_2v_3, v_3v_4, v_4v_5, v_4v_6, v_5v_6}
• Backbone string: T = v_1v_2v_3v_4v_5v_6
• All strings in R must be subsequences of the supersequence w

Solution mapping:

• The supersequence w = v_1v_2v_3v_4v_5v_6 of length 6 already contains every 2-symbol edge-string as a subsequence (since vertex symbols appear in order). The optimal SCS length relates to how many vertex symbols can be "shared" across edges.
• The vertex cover {v_1, v_3, v_4, v_6} identifies which vertices serve as shared anchors in the supersequence.

Verification:

• Each edge-string v_av_b (a < b) is a subsequence of v_1v_2v_3v_4v_5v_6 ✓
• The solution length relates to the vertex cover size through the reduction formula

References

• [Maier, 1978]: [Maier1978] David Maier (1978). "The complexity of some problems on subsequences and supersequences". Journal of the Association for Computing Machinery 25(2), pp. 322-336.
• [Räihä and Ukkonen, 1981]: K. J. Räihä and E. Ukkonen (1981). "The shortest common supersequence problem over binary alphabet is NP-complete". Theoretical Computer Science 16(2), pp. 187-198.
• [Lagoutte and Tavenas, 2017]: Aurélie Lagoutte and Sébastien Tavenas (2017). "The complexity of Shortest Common Supersequence for inputs with no identical consecutive letters". arXiv:1309.0422.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing path from MinimumVertexCover to ShortestCommonSupersequence
Non-trivial	✅ Pass	Encodes vertex cover constraints through subsequence containment — genuine structural transformation
Correctness	⚠️ Warn	References are real and the claimed VC→SCS reduction exists in the literature, but the described algorithm does not match any published construction
Well-written	❌ Fail	Algorithm is a high-level sketch (not implementable), overhead table uses non-existent field names, example does not demonstrate the reduction

Overall: 2 passed, 1 warning, 1 failed

---

Usefulness

Pass. There is no existing reduction path from MinimumVertexCover to ShortestCommonSupersequence in the codebase (pred path returns no path). This would be a novel edge in the reduction graph. The motivation is adequate — it explains the classical NP-completeness proof chain and why the reduction matters (Garey & Johnson SR8).

Non-trivial

Pass. The reduction from Vertex Cover to Shortest Common Supersequence is a well-known NP-completeness proof that involves encoding the "at least one endpoint must be covered" constraint through subsequence containment requirements. This is not a variable substitution, subtype coercion, or identity reduction. The actual published constructions (Maier 1978; Lagoutte & Tavenas 2015) involve intricate string gadgets.

Correctness

Warn. The cited references are real and correctly attributed:

• Maier 1978 — "The Complexity of Some Problems on Subsequences and Supersequences," JACM 25(2):322-336. Already in the project bibliography (maier1978). Correctly cited as the original NP-completeness proof for SCS. Garey & Johnson SR8 confirms "Transformation from VERTEX COVER."
• Raiha & Ukkonen 1981 — "The shortest common supersequence problem over binary alphabet is NP-complete," TCS 16(2):187-198. Also in the project bibliography. Real paper, correctly described.
• Lagoutte & Tavenas — "The complexity of Shortest Common Supersequence for inputs with no identical consecutive letters." The issue cites this as 2017, but the arxiv preprint is arXiv:1309.0422 (September 2013) and the paper date is January 8, 2015. Minor year discrepancy.

However, the reduction algorithm described in the issue body does NOT match any published construction. The actual Maier/Lagoutte-Tavenas constructions are far more complex. For example, the Lagoutte & Tavenas construction (Theorem 2.3) uses patterns like A_i = (0202)^{6n(i-1)+3n} 1 (0202)^{6n(n+1-i)} over a 3-symbol alphabet {0, 1, 2}, with string lengths on the order of O(n^2). The issue's described construction (one 2-symbol string per edge, a backbone string of all vertex symbols) is a plausible-sounding but fabricated sketch — it is marked with ⚠️ Unverified: AI-generated summary warnings, and the actual construction it describes would not constitute a valid reduction. The supersequence v_1 v_2 ... v_n trivially contains all 2-symbol subsequences regardless of vertex cover structure, so the proposed construction has no way to encode the cover constraint.

Since the references themselves are real and the reduction is known to exist, this is a warning rather than a failure — the issue correctly identifies that the reduction exists, but incorrectly describes how it works.

Well-written

Fail. Multiple issues:

4a — Information Completeness:

• The Reduction Algorithm section is marked ⚠️ Unverified: AI-generated summary and is a high-level sketch, not an implementable procedure.
• The Size Overhead section is marked ⚠️ Unverified: AI-derived overhead expressions and uses incorrect field names.

4b — Algorithm Completeness:

• The algorithm is a hand-wave, not a step-by-step implementable procedure. Steps 4-5 say "separator-delimited strings enforce that the vertex symbols appear in specific positions" and "The full construction uses the separator # to create blocks" without specifying what those strings actually are.
• Step 6-7 (correctness sketch) gives a vague intuition but not a proof. A programmer could not implement this reduction from the description given.
• The actual Maier/Lagoutte-Tavenas construction requires carefully designed string patterns over a fixed alphabet — none of this detail is present.

4c — Symbol and Notation Consistency:

• The overhead table uses num_strings, max_string_length, and bound_K — none of these are valid size fields on the ShortestCommonSupersequence target. The actual size fields are: alphabet_size, max_length, total_length.
• The overhead table references cover_bound as a source metric, but MinimumVertexCover's size fields are num_vertices and num_edges only — there is no cover_bound getter.
• The alphabet is described as having |V| + 1 symbols, but the published constructions use a fixed-size alphabet (size 3 or 5), not one that grows with the input.

4d — Example Quality:

• The first proposed vertex cover {v_2, v_3, v_4} of size 3 is incorrect (the issue itself identifies this failure), which is confusing. While it then provides a correct cover of size 4, the initial error adds unnecessary noise.
• The "Constructed target instance" section does not actually apply the reduction algorithm. It lists edge strings like v_1 v_2 and a backbone string, then observes that v_1 v_2 v_3 v_4 v_5 v_6 trivially contains all of them as subsequences. This means the example does not exercise the reduction — any permutation of symbols works, and the vertex cover structure plays no role.
• The "Solution mapping" section says "The optimal SCS length relates to how many vertex symbols can be 'shared' across edges" without specifying the relationship. This is not a worked example.
• The example is not round-trip testable because the reduction construction is not specified precisely enough to construct an actual SCS instance.

Recommendations

• The reduction algorithm needs to be replaced with the actual published construction. The Lagoutte & Tavenas (arXiv:1309.0422, Theorem 2.3) construction is the most accessible complete proof. It uses alphabet {0, 1, 2} and builds strings of length O(n^2) with specific (0202)^k patterns.
• Alternatively, Maier's original 1978 construction could be used, but it uses a larger alphabet (size 5) and is reportedly more complex.
• The overhead table must use the actual SCS size fields: alphabet_size, max_length, total_length.
• The example must show the actual string construction step by step and demonstrate that the SCS solution maps back to a valid minimum vertex cover.
• The year for Lagoutte & Tavenas should be corrected (the arxiv preprint is from 2013, not 2017).