[Rule] Vertex Cover to Multiple Copy File Allocation

[isPANN]

Source: VERTEX COVER (implemented in this repo as Decision<MinimumVertexCover<SimpleGraph, i32>> with all vertex weights set to 1)
Target: MULTIPLE COPY FILE ALLOCATION (implemented as a new decision wrapper Decision<MultipleCopyFileAllocation>, i.e. DecisionMultipleCopyFileAllocation)
Motivation: Use the uniform-cost strong-NP-completeness result for MULTIPLE COPY FILE ALLOCATION recorded by Van Sickle and Chandy (1977, IFIP Congress 77) and catalogued by Garey and Johnson (1979, Appendix A4.1 [SR6]). The right gadget is not “use the same graph and make access expensive”; that makes copies too cheap and collapses the optimum to “copy everywhere.” Instead, attach a hub that cheaply keeps every original vertex within distance 1, add two private leaves that force the hub into every optimum, and represent each source edge by two demand vertices whose distance jumps from 1 to 2 exactly when the edge is left uncovered. With uniform storage = 2 and uniform usage = 1, the normalized MCFA cost becomes n + 2m + 4 + |C| + 2·(# uncovered edges), so the decision threshold encodes a size-k vertex cover exactly.
Reference: Van Sickle and Chandy (1977, Information Processing 77 / IFIP Congress 77); Garey and Johnson (1979, Computers and Intractability, Appendix A4.1 [SR6], p. 227)

GJ Source Entry

[SR6] MULTIPLE COPY FILE ALLOCATION
INSTANCE: Graph G = (V, E), for each v ∈ V a usage u(v) ∈ Z⁺ and a storage cost s(v) ∈ Z⁺, and a positive integer K.
QUESTION: Is there a subset V' ⊆ V such that, if for each v ∈ V we let d(v) denote the number of edges in the shortest path in G from v to a member of V', we have

∑_{v ∈ V'} s(v) + ∑_{v ∈ V} d(v)·u(v) ≤ K ?

Reference: [Van Sickle and Chandy, 1977]. Transformation from VERTEX COVER.
Comment: NP-complete in the strong sense, even if all v ∈ V have the same value of u(v) and the same value of s(v).

Reduction Algorithm

Summary:
Let the source be a unit-weight VERTEX COVER instance (G = (V, E), k) with n = |V| and m = |E|. In repo terms, this is Decision<MinimumVertexCover<SimpleGraph, i32>> with all weights equal to 1 and decision bound k.

Because the codebase model MultipleCopyFileAllocation is an optimization problem over fields graph, usage, and storage, the actual target of the reduction should be a decision wrapper Decision<MultipleCopyFileAllocation> registered in the usual way:

• implement DecisionProblemMeta for MultipleCopyFileAllocation with DECISION_NAME = "DecisionMultipleCopyFileAllocation"
• add inherent getters on Decision<MultipleCopyFileAllocation> delegating to the inner problem: num_vertices(), num_edges(), and k() (the bound, converted to usize)
• invoke register_decision_variant! with size getters num_vertices and num_edges

The reduction itself is:

1. Graph gadget.
   Construct a graph H with four kinds of vertices:

   • a hub vertex r
   • two leaves p and q, each adjacent only to r
   • one original vertex x_v for each v ∈ V
   • for each source edge e = {u, v} ∈ E, two edge-demand vertices a_e and b_e

   Add edges:

   • {r, p} and {r, q}
   • {r, x_v} for every v ∈ V
   • {a_e, x_u}, {a_e, x_v}, {b_e, x_u}, {b_e, x_v} for every e = {u, v} ∈ E

   No other edges are added.

2. Uniform costs.
   Set

   • storage(z) = 2 for every vertex z ∈ V(H)
   • usage(z) = 1 for every vertex z ∈ V(H)

   This stays inside the uniform-cost regime explicitly noted by Garey and Johnson (1979, Appendix A4.1 [SR6]) for the Van Sickle-Chandy hardness result.

3. Decision bound.
   Set

   • K = n + 2m + 4 + k

4. No isolated-vertex precondition is needed.
   Unlike the broken same-graph draft, this gadget handles isolated source vertices directly. If v is isolated in G, then x_v is simply another spoke of the hub r; it contributes the same baseline access cost 1 whether or not it is selected, and it does not interfere with the cover accounting. In particular, the empty-edge case m = 0 is handled correctly: the source answer is YES iff k ≥ 0, and the target answer is YES via the single-copy placement {r}.

5. Normalization lemma.
   Any feasible MCFA solution S ⊆ V(H) can be transformed in polynomial time, without increasing cost, into a set of the form

   • S' = {r} ∪ {x_v : v ∈ C}
     for some C ⊆ V.

   The repairs are:

   • If p or q is selected, replace that leaf by r. Storage is unchanged and all distances weakly improve because r dominates both leaves and every original vertex.
   • After removing selected leaves, if r ∉ S, add r. This increases storage by 2, but decreases the access term by at least 3: r itself drops by at least 1, and each of p and q drops from distance at least 2 to distance 1.
   • With r selected, any selected edge-demand vertex a_e or b_e can be replaced by one of its endpoint vertices x_u or x_v without increasing cost. The replaced demand vertex goes from distance 0 to 1, but the newly selected endpoint goes from distance 1 to 0, and other distances weakly improve.

6. Cost formula in normal form.
   Fix C ⊆ V and consider S(C) = {r} ∪ {x_v : v ∈ C}.
   Let U(C) be the set of source edges uncovered by C.

   Then:

   • storage cost is 2(|C| + 1)
   • each of the two leaves contributes access cost 1
   • each unselected original vertex contributes access cost 1
   • for each covered source edge, both demand vertices are at distance 1, contributing 2
   • for each uncovered source edge, both demand vertices are at distance 2, contributing 4

   Therefore

   • cost(S(C)) = 2(|C| + 1) + 2 + (n - |C|) + 2(m - |U(C)|) + 4|U(C)|
   • cost(S(C)) = n + 2m + 4 + |C| + 2|U(C)|

7. Forward direction.
   If G has a vertex cover C with |C| ≤ k, then |U(C)| = 0, so

   • cost(S(C)) = n + 2m + 4 + |C| ≤ n + 2m + 4 + k = K
     Hence the constructed Decision<MultipleCopyFileAllocation> instance is YES.

8. Reverse direction.
   Suppose the MCFA instance has a solution of cost at most K.
   Normalize it to S(C) as above. Then

   • n + 2m + 4 + |C| + 2|U(C)| ≤ K = n + 2m + 4 + k
     so
   • |C| + 2|U(C)| ≤ k

   Now repair uncovered edges in the obvious way: for each uncovered source edge in U(C), add one of its endpoints to C. This produces a genuine vertex cover C* with

   • |C*| ≤ |C| + |U(C)| ≤ |C| + 2|U(C)| ≤ k
     Hence the source VERTEX COVER instance is YES.

9. Solution extraction.
   From any target witness, first normalize it to S(C) = {r} ∪ {x_v : v ∈ C}. Then repair uncovered edges as in Step 8 to obtain a source vertex cover C* of size at most k. This is polynomial-time witness extraction.

10. Time complexity.
    Building H, the uniform usage vector, the uniform storage vector, and the decision bound K takes O(n + m) time.

Size Overhead

Symbols:

• n = num_vertices of source graph G
• m = num_edges of source graph G
• k = source decision bound

Target metric (code name)	Polynomial
num_vertices	num_vertices + 2*num_edges + 3
num_edges	num_vertices + 4*num_edges + 2
k	num_vertices + 2*num_edges + 4 + k

Derivation:

• Vertices in H: n original vertices, 2m edge-demand vertices, one hub, and two leaves, for a total of n + 2m + 3.
• Edges in H: n hub-to-original edges, 2 hub-to-leaf edges, and 4m endpoint-incidence edges, for a total of n + 4m + 2.
• The target decision bound is K = n + 2m + 4 + k.
• Both cost vectors have length n + 2m + 3:
  • usage = [1; n + 2m + 3]
  • storage = [2; n + 2m + 3]

Validation Method

• Closed-loop test: start from a unit-weight Decision<MinimumVertexCover<SimpleGraph, i32>> instance, build the target Decision<MultipleCopyFileAllocation> instance, brute-force all copy placements, and verify:
  • VC(G) ≤ k iff MCFA(H) ≤ n + 2m + 4 + k
  • normalized target witnesses extract back to source covers of size at most k
• Corner case with isolated vertices: source graph on {0,1,2,3} with one edge {0,1} and isolated vertices 2,3, bound k = 1.
  • Here n = 4, m = 1, so K = 4 + 2 + 4 + 1 = 11.
  • The target YES witness {r, x_0} has cost exactly 11, so isolated vertices do not break the reduction.
• Empty-edge case: if E = ∅, then the source is always YES for k ≥ 0.
  • The target witness {r} has cost n + 4 = K when k = 0, so the reduction still matches.
• Worked cycle case: for C_6 and k = 3, the target optimum is exactly 25 (not 6, and not 114), attained by the hub plus the three alternating cover vertices.
• Adversarial non-cover check: for the same C_6, any normalized choice of only two source vertices leaves at least two source edges uncovered, so its cost is at least n + 2m + 4 + 2 + 2·2 = 28 > 25.

Example

Source instance (VERTEX COVER):
Let G = C_6 with vertices {0,1,2,3,4,5} and edges

• {0,1}, {1,2}, {2,3}, {3,4}, {4,5}, {5,0}

Take bound k = 3. This is a YES instance: for example,

• C = {1,3,5}
  is a vertex cover of size 3.

Constructed target instance (Decision):
Build H with:

• hub r
• leaves p, q
• original vertices x_0, x_1, x_2, x_3, x_4, x_5
• for each cycle edge e_i, two demand vertices a_i, b_i

Counts:

• num_vertices = 6 + 2·6 + 3 = 21
• num_edges = 6 + 4·6 + 2 = 32

Uniform costs:

• storage(z) = 2 for all 21 vertices
• usage(z) = 1 for all 21 vertices

Decision bound:

• K = n + 2m + 4 + k = 6 + 12 + 4 + 3 = 25

Solution mapping:
Take the copy set

• S = {r, x_1, x_3, x_5}

Its cost is:

• storage: 4 selected vertices, so 4·2 = 8
• access from unselected original vertices x_0, x_2, x_4: 3
• access from leaves p, q: 2
• access from the 12 demand vertices: every source edge is covered by {1,3,5}, so each demand vertex is at distance 1, contributing 12

Total:

• 8 + 3 + 2 + 12 = 25 = K

Verification:

• Forward: the source cover {1,3,5} of size 3 maps to an MCFA placement of cost exactly 25.
• Reverse: any normalized target solution has cost
  • 22 + |C| + 2|U(C)|
    because n + 2m + 4 = 22 here.
    So cost at most 25 implies
  • |C| + 2|U(C)| ≤ 3
    and the repair argument yields a vertex cover of size at most 3.
• For instance, C = {1,3} is not a cover of C_6; it leaves two edges uncovered, so its normalized MCFA cost is
  • 22 + 2 + 2·2 = 28 > 25

References

• [VanSickleChandy1977] Lawrence Van Sickle and K. Mani Chandy (1977). Computational Complexity of Network Design Algorithms. In Information Processing 77: Proceedings of IFIP Congress 77, pp. 235-239.
• [GareyJohnson1979] Michael R. Garey and David S. Johnson (1979). Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman. Appendix A4.1, entry [SR6].

[isPANN]

Issue Quality Check — Rule (Re-check)

Check	Result	Details
Usefulness	✅ Pass	No existing path from MinimumVertexCover to MultipleCopyFileAllocation; novel edge
Non-trivial	✅ Pass	Construction adds storage/usage cost gadgets — not a relabeling
Correctness	❌ Fail	Cost calibration is broken: V' = V always achieves cost n, smaller than the proposed bound; the reduction does not establish a vertex-cover ↔ minimum-cost-allocation correspondence (see worked counter-example below)
Completeness	❌ Fail	Algorithm assumes no isolated vertices (acknowledged inline but never enforced as a precondition or via preprocessing); traced corner cases (isolated vertex, single edge graph, the issue's own C₆ example) all break
Well-written	⚠️ Warn	Algorithm section is visibly "thinking aloud" with two competing constructions, mid-paragraph self-corrections ("Wait — more carefully..."), and a contradictory example that swaps from 7-edge graph to C₆. Two passes of the same uniform-cost construction (steps 1–6) reach opposite conclusions about K's formula

Overall: 2 passed, 2 failed, 1 warning

---

Usefulness

pred path MinimumVertexCover MultipleCopyFileAllocation returns "No reduction path". pred show MultipleCopyFileAllocation --json confirms reduces_from: []. So the rule, if correct, would add a useful new edge that establishes NP-hardness for MultipleCopyFileAllocation in our reduction graph. Garey & Johnson [SR6] confirm this is a well-known NP-completeness result, so the direction is right.

Non-trivial

The proposed mapping constructs new cost vectors u, s and a bound K over the same graph. That is a genuine cost-gadget construction, not a 1-to-1 relabeling — fine on Check 2.

Correctness

The construction (s(v) = 1, u(v) = M = n·m + 1 uniform) is mathematically broken. Verified numerically on the issue's own C₆ example:

n = 6, m = 6, M = 37
Issue's claimed bound: K = K_vc + (n - K_vc)·M = 3 + 3·37 = 114
Issue's claimed optimal V' = {1, 3, 5} (the MVC): cost = 3 + 3·37 = 114
Actual min-cost V' (brute force over all 63 nonempty subsets): V' = {0,1,2,3,4,5}, cost = 6

Picking V' = V (all vertices) always gives cost n·1 + 0 = n, which is much smaller than K_vc + (n - K_vc)·M for any reasonable M. So:

• For the optimization model (which is what the codebase actually exposes: MultipleCopyFileAllocation has Value = Min<i64> with no K parameter), the reduction maps MVC instances to MCFA instances whose minimum cost is n (achieved by V' = V), independent of MVC size — so opt-to-opt extraction is impossible.
• For the decision variant (which the issue's reasoning targets, since it picks a specific K), the answer to "does there exist V' with cost ≤ K?" is trivially YES via V' = V (cost = n ≤ K), so the reverse direction (cost ≤ K ⇒ |V'| ≤ K_vc) is false: V' = V has |V'| = n > K_vc whenever K_vc < n.

Root cause: the issue makes copies cheap (s = 1) and access expensive (u = M), which incentivizes placing copies everywhere — the opposite of what's needed to extract a small vertex cover. A correct reduction needs the storage cost to penalize over-placement (large s) while keeping access cheap enough to be tolerated only at distance ≤ 1 (or use non-uniform gadgets). Garey & Johnson [SR6] note NP-completeness "in the strong sense, even if all v ∈ V have the same value of u(v) and the same value of s(v)" — so a uniform-cost reduction does exist, but it is not the one written here.

Tried to verify against [Van Sickle and Chandy, 1977], "The complexity of computer network design problems", UT Austin tech report — paper is not in docs/paper/references.bib and is not freely available online (1977 internal tech report). The cited claim that VC reduces to MCFA is correct per G&J [SR6], but the specific construction in this issue is not the one in the literature: it is AI-generated (banner says "⚠️ Unverified: AI-generated summary below") and demonstrably wrong.

Completeness (mandatory for [Rule] issues)

Literature research. [Van Sickle & Chandy, 1977] is not accessible online for direct verification; G&J [SR6] only summarizes "Transformation from VERTEX COVER" without spelling out preconditions. Given that the issue's construction is broken, this check cannot be relied on for the issue's own algorithm.

Codebase corner cases for MinimumVertexCover. pred show MinimumVertexCover --json reports a SimpleGraph source with size fields num_vertices, num_edges. SimpleGraph instances can contain isolated vertices, disconnected components, multi-component graphs, and the empty graph.

Hand-traced the issue's algorithm against ≥ 2 corner cases beyond the worked example:

Corner case	Behaviour of the issue's algorithm
Single edge + 2 isolated vertices: n=4, E={(0,1)}, MVC = {0} (size 1)	Reduction sets M = n·m + 1 = 5, K = 1 + 3·5 = 16. But isolated vertices 2 and 3 have no path to any cover vertex, so d(2) = d(3) = ∞. The total_cost implementation in src/models/graph/multiple_copy_file_allocation.rs:138-143 returns None (infeasible) for any V' that leaves them unreachable. So V' must include all isolated vertices, which inflates `
4-cycle C₄: n=4, m=4, MVC = 2 (e.g., {0,2})	Reduction sets M = 17, K = 2 + 2·17 = 36. Brute force confirms min-cost V' = {0,1,2,3} with cost 4, not {0,2} with cost 36. So the decision query "exists V' with cost ≤ 36" succeeds via V' = V (
Empty graph (single isolated vertex): n=1, m=0, MVC = 0	M = 1, K = 0 + 1·1 = 1. Model requires V' nonempty, so V' = {0}, cost = 1 ≤ K. But MVC size is 0, while the reduction reports `
Issue's own C₆ example	As shown in Correctness above, min-cost V' = V (cost 6), not the claimed VC {1,3,5} (cost 114). Fails.

The algorithm is also not robust to the optimization-vs-decision distinction: the codebase has only the optimization model MultipleCopyFileAllocation (objective Min<i64>, schema fields graph, usage, storage — no K), but the issue's correctness argument is framed for the decision variant ("cost ≤ K"). If/when a DecisionMultipleCopyFileAllocation is added, the issue would still need to specify which target it's reducing to.

Well-written

• The Reduction Algorithm section contains a visible mid-construction self-correction ("Wait — more carefully...") and then restarts with a "Refined construction" that arrives at the same formula by a different argument — the section should be a single clean construction, not a transcript of the AI's reasoning.
• The Example section iterates through three different candidate source graphs before settling on C₆, with intermediate "Corrected" remarks. The final example is fine in isolation, but the body should be edited down before merging.
• Banner comments <!-- ⚠️ Unverified: AI-generated ... --> are present on every substantive section, including the algorithm, overhead, validation, and example — so the contributor has not yet vouched for the technical content.
• Size Overhead table is fine on its own (graph is unchanged, so num_vertices ↦ num_vertices, num_edges ↦ num_edges), but it omits the cost vectors and the bound K, which are also part of the target instance — once the algorithm is rewritten, the overhead description should mention how K, u, s scale with the source.

Verdict

This issue is not implementable as written. The correctness flaw is fundamental, not a typo — the cost-calibration direction is inverted, so no constant M rescues the construction. Suggested next steps for the proposer:

1. Reverse the cost direction. A working uniform-cost reduction needs large storage cost (so adding extra copies hurts) and small enough usage that distance-1 access is tolerable but distance-≥2 is not. One classical pattern: s(v) = 1, u(v) = 1, K = K_vc + (n − K_vc) · 1, with the source restricted to graphs of diameter ≤ 2 — but this needs a non-trivial gadget for general graphs.
2. Track down the actual Van Sickle & Chandy 1977 construction (UT Austin TR-115 or similar). If the technical report is inaccessible, an alternative citable source for the VC → MCFA reduction is needed.
3. State a precondition or preprocessing step to handle isolated vertices and disconnected components, since MinimumVertexCover in the codebase accepts both.
4. Decide which target you're reducing to: the optimization version (MultipleCopyFileAllocation, currently in the codebase) or a decision variant (would need to be added first as a separate [Model] issue).

Labels added: Wrong, Incomplete. (The well-written warning is non-blocking on its own; the failure labels already gate this issue.)

[isPANN]

auto-pipeline: issue body rewritten by codex xhigh (substantive retry 1)

[isPANN]

Issue Quality Check — Rule (Re-check, round 2 after codex rewrite)

Check	Result	Details
Usefulness	Pass	pred path MinimumVertexCover MultipleCopyFileAllocation and pred path DecisionMinimumVertexCover MultipleCopyFileAllocation both return "no path" — novel edge into MCFA's sub-graph
Non-trivial	Pass	Hub + 2 private leaves + per-edge demand vertices is a genuine gadget construction, not a relabeling
Correctness	Pass	Van Sickle & Chandy 1977 and Garey-Johnson 1979 [SR6] both already in docs/paper/references.bib; cost formula `cost(S(C)) = n + 2m + 4 +
Completeness	Fail	Blocked — target wrapper DecisionMultipleCopyFileAllocation does not exist on main; corner-case math is correct but the rule cannot be implemented as a standalone [Rule] PR
Well-written	Pass	All template sections substantive; symbols n, m, k, C, U(C) consistently defined; overhead table matches actual construction sizes

Overall: 4 passed, 1 failed (blocked on prerequisite)

---

Usefulness

Confirmed novel via pred path:

• pred path MinimumVertexCover MultipleCopyFileAllocation → "No reduction path"
• pred path DecisionMinimumVertexCover MultipleCopyFileAllocation → "No reduction path"

This is the first edge connecting any vertex-cover variant to the MCFA sub-graph. Motivation cites the right G&J entry [SR6] and the original Van Sickle-Chandy result, so the chain into MCFA closes the orphan.

Non-trivial

The construction adds:

• a hub vertex r,
• two private leaves p, q forcing r into every optimum,
• n original vertices x_v attached to the hub,
• 2m per-edge demand vertices a_e, b_e adjacent to both endpoint-images.

This is structural (gadgets + cost calibration), not a relabeling.

Correctness

References:

• [VanSickleChandy1977] — already in docs/paper/references.bib (Information Processing 77 / IFIP Congress 77, pages 235-239).
• [GareyJohnson1979] — Computers and Intractability, Appendix A4.1 [SR6], p. 227. Quote in the issue matches the G&J entry verbatim ("NP-complete in the strong sense, even if all v ∈ V have the same value of u(v) and the same value of s(v)").

Hand-derivation of cost(S(C)) = n + 2m + 4 + |C| + 2·|U(C)|:

• storage = 2·(1 + |C|) = 2 + 2|C|
• access from leaves: 1 + 1 = 2
• access from unselected x_v: n - |C|
• access from 2m demand vertices: 2·(m - |U(C)|) + 4·|U(C)| = 2m + 2|U(C)|
• sum: 2 + 2|C| + 2 + (n - |C|) + 2m + 2|U(C)| = n + 2m + 4 + |C| + 2|U(C)| ✓

Reverse-direction repair: from |C| + 2|U(C)| ≤ k, picking one endpoint per uncovered edge gives |C*| ≤ |C| + |U(C)| ≤ |C| + 2|U(C)| ≤ k, which is a valid vertex cover. ✓

Cited as uniform-cost regime (u = 1, s = 2), which stays inside the strong-NP-completeness setting G&J explicitly call out, so the construction is mapping into the actually-hard sub-problem.

Completeness

Hand-traced corner cases (required by /check-issue Rule Check 5):

1. Empty-edge case m = 0 (e.g., n = 4, k = 0).

   • K = 4 + 0 + 4 + 0 = 8.
   • With S = {r}: storage 2, leaves at distance 1 each (cost 2), all 4 x_v at distance 1 (cost 4). Total = 8 = K. Target YES. Source YES (empty cover works). ✓
   • Issue's claim "target witness {r} has cost n + 4 = K when k = 0" matches (because 2m = 0).

2. Isolated vertices (n = 4, m = 1, k = 1, edge {0,1}, vertices 2 and 3 isolated).

   • K = 4 + 2 + 4 + 1 = 11.
   • S = {r, x_0}: storage 4, x_0 cost 0, x_1, x_2, x_3 cost 1 each (3), leaves cost 2, a_e, b_e cost 1 each (2). Total = 11 = K. ✓
   • Isolated x_2, x_3 are just additional spokes of the hub; they don't break the formula.

3. Cubic-ish small graph (C_6, n = 6, m = 6, k = 3, issue's worked example).

   • K = 6 + 12 + 4 + 3 = 25.
   • C = {1, 3, 5} covers all 6 edges; cost(S(C)) = 22 + 3 + 0 = 25 = K. ✓
   • Adversarial C = {1, 3} leaves edges {4,5} and {5,0} uncovered: cost = 22 + 2 + 2·2 = 28 > 25. ✓ matches the issue's worked adversarial check.

4. m = 1, k = 0 (n = 2, single edge, infeasible source).

   • Source NO (any cover of one edge has size ≥ 1).
   • K = 2 + 2 + 4 + 0 = 8. Minimum target cost over normalized solutions: cost(S(∅)) = 2 + 2 + 4 + 0 + 2 = 10, cost(S({u})) = 2 + 2 + 4 + 1 + 0 = 9. Min = 9 > 8 → target NO. ✓

The math is sound and the gadget handles every corner case I traced.

However: BLOCKED.

The target Decision<MultipleCopyFileAllocation> (i.e. DecisionMultipleCopyFileAllocation) does not exist on main:

• pred show DecisionMultipleCopyFileAllocation → "Unknown problem"
• src/models/graph/multiple_copy_file_allocation.rs does not call decision_problem_meta! or register_decision_variant!
• the file declares MultipleCopyFileAllocation but no decision wrapper

The issue itself acknowledges this and lists the implementation steps for the wrapper (DecisionProblemMeta, inherent getters, register_decision_variant!). Per the project convention in .claude/skills/issue-to-pr/SKILL.md — "[Rule] issues still require both models to exist on main" — this rule cannot be implemented as a single [Rule] PR. It needs a prerequisite [Model] (or wrapper-only) PR first that adds Decision<MultipleCopyFileAllocation>.

Recommended remediation (pick one):

• Split into two issues: a [Model] issue for the DecisionMultipleCopyFileAllocation wrapper, then this [Rule] issue depending on it.
• OR retarget the rule at the optimization problem MultipleCopyFileAllocation directly (aggregate-only reduction) rather than the decision wrapper, then add Decision later.
• OR explicitly mark this as a combined model+rule PR; in that case the issue should be re-tagged or the scope rule needs an exception note.

Well-written

All template sections are present and substantive:

• Source / Target: precise (including the variant constraint "all weights = 1" on the source).
• Motivation: explains why the previous "use the same graph and make access expensive" sketch fails and what the gadget achieves.
• Reference: two specific citations, both verified in references.bib.
• Reduction Algorithm: 10 numbered steps; normalization lemma proven; forward and reverse directions stated separately.
• Size Overhead: table matches construction exactly (n + 2m + 3 vertices, n + 4m + 2 edges, K = n + 2m + 4 + k).
• Validation Method: enumerates the closed-loop test plus isolated/empty/cubic corner cases.
• Example: full C_6 worked instance with explicit cost decomposition and an adversarial non-cover check.

Symbols are consistent across sections (n, m, k, C, U(C), S(C)).

Recommendations

• The first prerequisite to unblock this rule is to register Decision<MultipleCopyFileAllocation> (decision_problem_meta + register_decision_variant) on main. The issue body already lays out the steps; spinning it out as a tiny model-only PR is the cleanest fix.
• Once the wrapper exists, this rule is essentially ready: the normalization lemma is the only step a reviewer would want to see covered in a unit test, ideally by including a S = {p} start state and checking the implementation actually normalizes it before computing cost.