Persistent copying and changing ancestor answers

12 October 2026. Assessment 210. Dedicated primary-proof review. Native theorem 68 and the routed subclass remain unchanged.

What the comparison resolves

A persistent representation can retain old subtrees cheaply while leaving their new combined answers expensive. The relevant distinction is between copying an occurrence and combining the predicates attached to the same ordinary query. The two primary proofs below make that distinction operational: one accelerated cache requires that old ancestor answers stay unchanged; the other supports grafting already located subtrees, without recursively merging colliding keys.

This rules out two direct transfers to the late-shorter-context target. It does not rule out a stronger readout. The next test is a versioned ancestor overlay that preserves old kernels and resolves their current Boolean union during the actual query, without replaying a growing overlay chain. No new native theorem or root admission follows from this review.

Primary proofs and exact hypotheses

Fiat and Kaplan, Making data structures confluently persistent, author manuscript of the 2003 Journal of Algorithms paper. Independent review covered the complete 40-page manuscript. Sections 1.1–1.2 specify constant-field pointer structures, fixed access pointers and word-RAM resources. Theorem 2.1 constructs copied binary-tree occurrences and independently assigned bits: for the stated version-DAG and assignment-size conditions, occurrence multiplicity forces storage proportional to effective depth per assignment. It is a storage theorem, not a bounded-local-query theorem. Sections 4–5 identify occurrences by version pedigrees, retrieve the latest applicable field assignment by longest-prefix search, and repair pointer pedigrees by prefix substitution. The deterministic full/compressed methods charge actual/effective version depth. Crucially, Section 6.2 forbids adding a sequence that prefixes an existing sequence; Section 6.2.1 uses that promise to leave old cached answers unchanged. Section 6’s accelerations also introduce randomized error and amortized/deferred work. These are not strict exact native operations.

Demaine, Langerman and Price, Confluently Persistent Tries for Efficient Version Control, Algorithmica 57 (2010), 462–483. The complete 18-page paper was studied. Section 2, Theorem 1, maintains a constant-size compressed Steiner skeleton on constantly many fingers; path deques and hanging subtries support local navigation and grafting in $O(\log\Delta)$ time and space. Sections 3.1–3.4, Theorem 2, replace parent pointers by relative fingers in a heavy-path representation. Telescoping biased-tree depths yield $O(\log n)$ updates; deque-of-deques fingers support navigation in $O(\log\Delta)$ time without allocation. Section 3.3 explicitly repairs each of the constantly many passive fingers. Sections 4–5 improve high-degree navigation with fully persistent hashing: pristine/active version pairs, update logs and replay pay rebuilding across persistent branches. The hashing bounds are expected/amortized and the structures cease to be purely functional. Subtree copy attaches a located subtree; none of these theorems supplies same-key Boolean union.

For precision, the first paper defines $e(u)=1+\log_2|R(u)|$, where $R(u)$ is the set of root-to-$u$ version paths. Theorem 2.1 assumes $k=\Omega(|E|^2)$ and $e(u)>2\log_2 k$ and produces an instantiation requiring $\Omega(k e(u))$ bits for the selected assignments. Its proof charges $O(|E|^2)$ construction assignments but does not bound the many retrievals used to locate or decode the chosen occurrences. The deterministic methods charge $O(d(v)+\log F)$ or $O(e(v)+\log F)$ per retrieval/assignment, with assignment storage $O(d(v))$ or $O(e(v))$ words, respectively. Here $d$ is version depth and $F$ bounds assignments to one field family; neither is an ordinary target-name length.

The earlier assessments 96–97 already used the locality-sensitive skeleton from the second paper. This review does not count that mechanism again. Its additional comparison covers the global balancing, finger repair and persistent rebuilding arguments, and the first paper’s original lower bound and cache-insertion premise.

What can be transferred, and what cannot

The papers’ models are compatible rather than contradictory. The generic storage lower bound permits identifying many copied occurrences through sufficiently long traversals. The trie interface charges navigation from constantly many fingers. It is not a free arbitrary-occurrence selector. Conversely, restricting degree to two makes local trie operations constant cost, but does not make an unspecified merge of two whole tries into one local operation.

The native transfer still has to fix degree, radius, finite labels/control, old-top semantics, initialization and literal input orientation. All preparation, allocation, retained storage, pointer/name routing and old-storage observations count against actual encoded input length $N$. A logarithmic update bound cannot be charged to a constant-length final delimiter, and amortized replay cannot be moved past a final-symbol answer. Neither version pedigrees nor RAM addresses may become advice, metadata or a control-flow communication channel. No language lower bound or direct PEG consequence is inferred here; native recognition would retain the established reversal convention.

A concrete cache failure when the premise is dropped

Here is a written counterexample to extending the accelerated cache outside its stated insertion contract. It is not a counterexample to the paper.

For a word of length 13, the sampled-prefix lengths are 8, 12 and 13. Start with the sole stored integer sequence $1^{13}$. The cache entry for the sample $1^8$ records that no full stored sequence prefixes it. Now introduce the shorter sequence $1^4$, adding only its own sampled entry and leaving old entries unchanged. Query $1^8$. It is already a sampled key, so its cached answer remains absent, although its correct longest stored prefix is now $1^4$.

All sequences here consist of positive unit integers. Their different prefix lengths have different sums, so the witness does not depend on hash collisions or on violating the paper’s unique-sums hypothesis. The only removed premise is the prohibition on introducing an ancestor. We even grant correct installation of the new full-key answer; that does not repair the old length-eight sample.

The exact-key version has unbounded fan-out. For each seven-bit word $b$, insert the length-13 word $1b00000$. There are 128 distinct length-eight samples $1b$, all initially caching absence. Inserting the prefix 1 changes the correct answer at every one of them. More generally, arbitrarily many distinct sampled extensions can lie below one newly inserted ancestor. This is a failure of updating only the new sequence’s cache entries, not a lower bound on all representations: one shared override can describe the common change.

The witness is a mechanism analogy, not a reduction from content contexts to version pedigrees. The native problem additionally has source-specific selections and different residual coordinates. A successful override must address those obligations too.

Carrying the proposed repair to its actual bottleneck

The obvious repair is to retain the old cache and attach an ancestor override to the new version. Semantically that suffices for the common longest-prefix change above. It does not yet supply a bounded-cost query: a query must find the applicable override, compare specificity with any old answer, and preserve the answers of old versions. A linked history merely defers the growing traversal. A rebuilt directory must account for every copied path and its release deadline.

More importantly, context reuse asks for OR, not replacement. Write $K_c(A_c,y)$ for the exact answer of a retained child kernel in its current selected state. For an ordinary target $w$, the required interface is

$$U(A,w)=\bigvee_{c\preceq w}K_c(A_c,w[|c|:]).$$

Only existing applicable kernels contribute; this formula is a semantic specification, not a charged algorithm. Taking the newest or most specific applicable kernel is unsound: two applicable answers can be $(1,0)$ or $(0,1)$, and either single-choice rule loses one case. A common prefix marker also cannot answer arbitrary residual membership. If all contributions are false, exact negative output must certify the entire current disjunction through some prepared or incrementally maintained representation.

Subtree grafting does not implement this formula automatically. Two retained roots can both need the same next input bit. Replacing one edge loses a contributor; attaching them under fresh selector tags changes the ordinary query; retaining an OR node creates an additional readout task. Those are failures of these wrappers, not a native impossibility result. The local trie theorem remains useful for maintaining whatever directory a successful stronger interface provides.

The next construction should keep a versioned contributor directory, distinct from a longest-prefix winner directory. Test it first on nested contexts with arbitrary short aliases. For each new shorter context, identify which retained handles change interpretation, when each residual reader starts, and how an interrupted union remains exactly queryable. A successful schedule must pay every overlay traversal or replace it by a charged aggregate whose maintenance fits actual input. Test both selected-state collisions above and an all-negative query immediately after the shortest permitted selection. No hidden suffix replay, ready handles, padding or EOF drain is allowed.

This comparison does not establish that the proposed directory can meet those conditions. The attempt stops at current union access and residual-start timing, which is the substantive unresolved operation rather than a storage-size ambiguity.

Evidence, review and handoff

The exact-key cache audit checks 24,060 queries under legal two-insertion orders, 2,040 queries under forbidden ancestor insertions, and 26,100 retained-version answers. It finds 32 stale answers in the forbidden cases, checks the positive-unit length-13 witness, and checks the 128-sample fan-out witness. Its Python tuples and dictionary searches are semantic oracles, not a native implementation or probabilistic hash simulation. The selected-state truth table is a small diagnostic, not evidence for a complexity bound.

An independent adversarial reviewer reconstructed the first paper’s full proof chain, identified the insertion premise and unary witness, and reviewed this comparison. Primary PDFs and extracted text remain outside public source. Pins for the inspected author PDFs are:

• Fiat–Kaplan SHA-256: 57f7de59f627cb4b70c508c4e733dea495c7de9957f77b4a6ea4affd09b51693.
• Demaine–Langerman–Price SHA-256: 8768751ba0e092cf1e2ba27ebbb0bc73f77e86b3a7ba60e1b01079fcc896a5a6.

The contribution is a primary-proof comparison and an elementary failure witness for a deliberately weakened cache contract, with high confidence in that limited classification. It is neither a new persistence theorem nor evidence of priority for a general composition criterion. The potential new content remains the charged contributor interface, which these imported proofs do not provide.

The routed subclass remains the positive control: early unique routing chooses one group and avoids growing simultaneous readout. Replay slices still pay each branch’s service. Affine-fragment joins do not supply independent-store conversion; persistent causal algebra preserves histories without paying access; unary coherent cubical algebra does not close growing-branch readout. All prior SAT/scaffold frontiers and entry 129’s growing-alphabet state/port qualifications remain retained.

Scheduled 114 to 115 once. Mathematical 131, window three, reassessment 128 and native theorem 68 are unchanged. Next 116 is research; dedicated review and editorial duties both recur at 120. The exact main target is preserved: construct or refute the charged late-shorter-context union interface, with bounded active readers and no lost residual-start budget. Clipped-cone intervals and independent-store joins remain separate. Publication and scoped validation receipts belong in integration state; no new paper or homepage research-date promotion is warranted.