[Rule] Rooted Tree Arrangement to Rooted Tree Storage Assignment

[isPANN]

Source: Rooted Tree Arrangement
Target: Rooted Tree Storage Assignment
Motivation: Establishes NP-completeness of ROOTED TREE STORAGE ASSIGNMENT by reduction from ROOTED TREE ARRANGEMENT. The key idea is that an optimal embedding of a graph into a rooted tree (minimizing total edge-stretch) can be re-encoded as a storage assignment problem: each edge {u,v} of the source graph becomes a "requirement set" {f(u), f(v)} that must lie on a directed path in a rooted tree, and the cost of extending subsets to form directed paths corresponds to the edge distances in the tree arrangement. Gavril (1977) showed this transformation is polynomial and preserves the YES/NO answer.

Reference: Garey & Johnson, Computers and Intractability, Appendix A4.1 [SR5], p.227

GJ Source Entry

[GT45] ROOTED TREE ARRANGEMENT
INSTANCE: Graph G = (V, E), rooted tree T = (U, F) with |U| = |V|, positive integer K.
QUESTION: Is there a one-to-one mapping f: V → U such that ∑_{{u,v} ∈ E} d_T(f(u), f(v)) ≤ K?
Reference: Garey & Johnson, Computers and Intractability, [GT45], p.209.

[SR5] ROOTED TREE STORAGE ASSIGNMENT
INSTANCE: Finite set X, collection C = {X_1, X_2, ..., X_n} of subsets of X, positive integer K.
QUESTION: Is there a collection C' = {X_1', X_2', ..., X_n'} of subsets of X such that X_i ⊆ X_i' for 1 ≤ i ≤ n, such that ∑_{i=1}^{n} |X_i' − X_i| ≤ K, and such that there is a directed rooted tree T = (X, A) in which the elements of each X_i', 1 ≤ i ≤ n, form a directed path?
Reference: [Gavril, 1977a]. Transformation from ROOTED TREE ARRANGEMENT.

Reduction Algorithm

Summary:
Given a ROOTED TREE ARRANGEMENT instance: graph G = (V, E) with |V| = n vertices and positive integer K, construct a ROOTED TREE STORAGE ASSIGNMENT instance as follows:

1. Universe: Set X = V (the vertex set of G). The universe has |X| = n elements.

2. Collection of subsets: For each edge {u, v} ∈ E, create a subset X_e = {u, v} containing exactly the two endpoints of the edge. The collection is C = {X_e : e ∈ E}, with |C| = |E| subsets, each of size 2.

3. Bound: Set K' = K − |E|. (Each required subset has size 2, so forming a directed path through both endpoints requires at least 1 additional element if they are not adjacent in the tree, or 0 if they are parent-child. The total extension cost corresponds to the total edge distance minus the minimum |E| cost of traversing each edge.)

4. Correctness (forward): If there exists a rooted tree T = (U, F) with |U| = n and a one-to-one mapping f: V → U such that (a) for every edge {u,v} ∈ E, f(u) and f(v) lie on a common root-to-leaf path in T, and (b) ∑_{{u,v} ∈ E} d(f(u), f(v)) ≤ K, then we can construct extended subsets X_e' for each edge e = {u,v} by taking all tree nodes on the path from f(u) to f(v) in T. The total extension cost ∑ |X_e' − X_e| = ∑ (d(f(u),f(v)) − 1) = (∑ d(f(u),f(v))) − |E| ≤ K − |E| = K'.

5. Correctness (reverse): If there exists a valid storage assignment with extended subsets forming directed paths in some rooted tree T = (X, A) with total extension cost ≤ K', then the same tree T with the identity mapping gives a rooted tree arrangement with total distance ∑ d(u,v) ≤ K' + |E| = K.

6. Solution extraction: Given a valid storage assignment (a rooted tree T and extended subsets), the rooted tree arrangement is the same tree T with the identity embedding f(v) = v, and the arrangement cost is K' + |E|.

Key invariant: The extension cost for a single edge subset {u,v} equals d(u,v) − 1 in the rooted tree (number of intermediate nodes on the path), so total extension cost = total arrangement cost − |E|.

Time complexity of reduction: O(|E|) to construct the subsets.

Size Overhead

Symbols:

• n = num_vertices of source graph G (|V|)
• m = num_edges of source graph G (|E|)

Target metric (code name)	Polynomial (using symbols above)
universe_size	num_vertices (= n)
num_subsets	num_edges (= m)

Derivation: The universe X is exactly the vertex set V, so |X| = n. Each edge becomes one 2-element subset, giving |C| = m subsets. The bound K' = K − m is derived from the source bound.

Validation Method

• Closed-loop test (test_rooted_tree_arrangement_to_rooted_tree_storage_assignment_closed_loop): Construct a ROOTED TREE ARRANGEMENT instance, reduce to ROOTED TREE STORAGE ASSIGNMENT, solve target by brute-force, extract solution back, verify the recovered tree arrangement satisfies the original bound.
• Path graph P_6 (6 vertices, 5 edges, chain 0–1–2–3–4–5): optimal arrangement embeds into a rooted path with total distance 5. Reduced instance has K' = 5 − 5 = 0 (no extensions needed, every edge is already a parent-child pair). Verify brute-force target solution has extension cost 0.
• Star graph K_{1,5} (6 vertices, 5 edges, center 0): optimal rooted star at 0 gives total distance 5, K' = 0. Verify solution requires no extensions.
• Unsatisfiable K_4 (4 vertices, 6 edges, K = 7): any rooted tree on 4 vertices has diameter ≤ 3, so total distance ≥ 8 for K_4. With K = 7 the arrangement is infeasible; verify brute-force returns no solution.

Example

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

• Edges: {0,1}, {1,2}, {2,3}, {0,4}, {4,5}, {1,3}, {0,2}
• Bound K = 9.

Rooted tree T with root 0:

    0 → 1 → 2 → 3
    |
    4 → 5

• d(0,1) = 1, d(1,2) = 1, d(2,3) = 1, d(0,4) = 1, d(4,5) = 1
• d(1,3) = 2 (path 1→2→3, both on same root-to-leaf path)
• d(0,2) = 2 (path 0→1→2, both on same root-to-leaf path)
• Total distance = 1+1+1+1+1+2+2 = 9 ≤ K = 9 ✓

Constructed target instance (RootedTreeStorageAssignment):

• Universe X = {0, 1, 2, 3, 4, 5}, |X| = 6
• Collection C (one subset per edge):
  • X_1 = {0, 1}, X_2 = {1, 2}, X_3 = {2, 3}, X_4 = {0, 4}, X_5 = {4, 5}, X_6 = {1, 3}, X_7 = {0, 2}
• |C| = 7 subsets
• Bound K' = K − |E| = 9 − 7 = 2

Solution mapping (using the same rooted tree T):

• X_1' = {0, 1}: path 0→1. Extension cost = 0.
• X_2' = {1, 2}: path 1→2. Extension cost = 0.
• X_3' = {2, 3}: path 2→3. Extension cost = 0.
• X_4' = {0, 4}: path 0→4. Extension cost = 0.
• X_5' = {4, 5}: path 4→5. Extension cost = 0.
• X_6' = {1, 2, 3}: path 1→2→3, extending {1,3} by adding {2}. Extension cost = 1.
• X_7' = {0, 1, 2}: path 0→1→2, extending {0,2} by adding {1}. Extension cost = 1.
• Total extension cost = 0+0+0+0+0+1+1 = 2 ≤ K' = 2 ✓

Verification:

• Total arrangement distance = total extension cost + |E| = 2 + 7 = 9 ≤ K = 9 ✓
• Each extended subset forms a directed path in the rooted tree ✓
• Each original subset is contained in its extension ✓

References

• [Gavril, 1977a]: [Gavril1977a] F. Gavril (1977). "Some NP-complete problems on graphs". In: Proceedings of the 11th Conference on Information Sciences and Systems, pp. 91-95. Johns Hopkins University.

[zazabap]

Issue Quality Check — Rule

Check	Result	Details
Usefulness	✅ Pass	No existing reduction path RootedTreeArrangement → RootedTreeStorageAssignment
Non-trivial	✅ Pass	Genuine structural transformation: graph embedding → set-system path-cover problem
Correctness	⚠️ Warn	References verified but original Gavril 1977 conference paper is not freely available for full claim verification
Well-written	❌ Fail	Multiple issues: example contains false starts, irrelevant reference, validation method is vague

Overall: 2 passed, 1 warning, 1 failed

---

Usefulness

Pass. No reduction path currently exists between RootedTreeArrangement and RootedTreeStorageAssignment in the reduction graph. Both models already exist in the codebase but are currently isolated from each other (RootedTreeArrangement has no outgoing reductions; RootedTreeStorageAssignment only reduces to ILP). This rule would establish a novel connection.

The motivation is substantive — it explains that the reduction establishes NP-completeness of the target by transformation from the source, citing Gavril (1977).

Non-trivial

Pass. The reduction involves a genuine structural transformation:

• Converts a graph embedding/arrangement problem into a set-system with rooted-tree path constraints
• The universe becomes the vertex set, each edge becomes a 2-element subset
• The bound adjustment (K' = K − |E|) reflects the relationship between tree distance and path extension cost
• This is not a mere relabeling or subtype coercion — it bridges two different problem formulations (graph arrangement vs. set storage)

Correctness

Warn — partial verification only.

References verified:

• Gavril (1977): "Some NP-Complete Problems on Graphs", Proc. 11th Conference on Information Sciences and Systems, pp. 91–95, Johns Hopkins University. This paper exists in the project bibliography (docs/paper/references.bib, key gavril1977) and is confirmed on Semantic Scholar. The paper is a conference proceedings paper that is not freely available online, so the specific claim that it contains the RootedTreeArrangement → RootedTreeStorageAssignment reduction cannot be independently verified from the abstract alone. However, the Garey & Johnson entry [SR5] explicitly cites "[Gavril, 1977a]. Transformation from ROOTED TREE ARRANGEMENT" which corroborates the claimed reduction.
• Garey, Johnson, and Stockmeyer (1976): "Some simplified NP-complete graph problems", Theoretical Computer Science 1(3), pp. 237–267. Verified on ScienceDirect. However, this paper is about simplified graph problems (planar restrictions, bounded degree), not about tree arrangement/storage assignment. Its relevance to this reduction is unclear — the issue cites it but never explains what result from this paper is used.

Reduction algorithm analysis:

• The core invariant (extension cost for edge {u,v} = d_T(u,v) − 1) is correct given the ancestor-comparability constraint
• The forward and reverse correctness arguments are logically sound
• The implementation of RootedTreeArrangement in the codebase confirms the ancestor-comparability requirement (are_ancestor_comparable() check), which is consistent with the reduction's assumption that all edge pairs lie on directed paths

Issue: The reference to Garey, Johnson, and Stockmeyer (1976) appears to be irrelevant to this specific reduction. The issue should clarify why this paper is cited or remove it.

Well-written

Fail. Several issues found:

4a — Information Completeness:

• All required sections are present ✓
• However, the issue lacks the GJ source entry for the source problem (Rooted Tree Arrangement) — only the target [SR5] is quoted

4b — Algorithm Completeness:

• The step-by-step procedure is clear and implementable ✓
• Solution extraction is described ✓

4c — Symbol and Notation Consistency:

• The overhead table uses num_vertices and num_edges from the source problem, which are valid getter methods on RootedTreeArrangement ✓
• The target metrics universe_size and num_subsets match RootedTreeStorageAssignment's size_fields ✓
• However, the source problem has empty size_fields in the registry. The overhead expressions reference num_vertices and num_edges which exist as getter methods but are not registered as size fields. This may cause issues with the #[reduction(overhead = ...)] macro. The issue should note this or propose adding size field registrations to the source model.

4d — Example Quality:

• Contains false starts and self-corrections — the example tries a tree, discovers it doesn't work ("2 and 3 are siblings, not on same path!"), then tries another tree. While the final result is correct, a polished issue should present only the working solution. The false starts make it confusing and suggest the example was not carefully reviewed.
• Round-trip testable: The example has 6 vertices, 7 edges, and a non-trivial tree structure with extension costs. The total distance (9) is well below K=12, meaning the bound is very loose. A tighter bound would make the example more discriminating — with K=12, many suboptimal arrangements also satisfy the bound, reducing the test's ability to catch bugs. Recommendation: Use K=9 or K=10 so the example is closer to the boundary.
• Validation Method section is vague: "solve target by brute-force (enumerate all rooted trees on n nodes...)" is a description of what brute-force means, not a concrete validation procedure. The validation test cases are reasonable (path graph, star graph, unsatisfiable case) but they are described informally rather than as precise test specifications.

Recommendations

• Remove the false-start tree from the example; present only the working chain tree directly
• Tighten the bound K to make the example more discriminating (e.g., K=9 or K=10)
• Clarify why Garey, Johnson, and Stockmeyer (1976) is cited, or remove it if irrelevant
• Add the GJ source entry for Rooted Tree Arrangement (the source problem) for completeness
• Consider noting that the source model's size_fields are currently empty in the registry