A current selector cannot be copied into every owner path cheaply

Assessment 246, 13 October 2026 local research date. Research resumed after review 245. This is a failed direct-selector implementation with an exact restricted copying argument and a contrasting shared representation. Construction 85 remains the latest native theorem; no root admission or general native lower bound is claimed.

Strongest statement and payoff

The proposed repair was to duplicate a source’s current bucket descriptors into an owner-shaped index. Reading the ordinary owner would then finish at the correct current descriptor, removing the late destination lookup identified in assessment 244. The repair fails when implemented as an eager immutable tree: updating one bucket can force exponentially many owner-path copies.

The same family admits a small suffix-only index. Thus the useful distinction is not how many owners share an answer, but whether their selector behavior has a shared representation that ordinary input can build, maintain and traverse in time. This assessment does not complete that native construction. It narrows the next attempt to a paid quotient of selector behavior and explicitly rejects an owner-by-owner current shadow as a general repair.

1. The attempted current shadow and exact contract

Fix a finite prefix-free set of binary owners and its ordinary binary prefix tree. Each owner terminal is a distinct node. A static right table assigns each owner to a bucket or other shared answer class. For one current source, every terminal in class $c$ directly stores a pointer to the same current immutable descriptor $B_c$. All logical prefix nodes have their prescribed children. The reader follows the arriving owner bits and takes that terminal’s descriptor directly.

Changing a bucket creates a fresh immutable descriptor $B'_c$ and must produce a complete current shadow with the same prefix-tree shape. Nodes outside the changed paths may be shared. This contract excludes mutable forwarding, lookup in a separate override dictionary, lazy capsule interpretation, quotient/DAG sharing of logical owner nodes, and prebuilt complete future shadows. These are substantive representation restrictions. They are not properties of all native machines.

Define the affected prefix set, including terminals and the root, by

$$A_c=\{p: p\text{ is a prefix of an owner assigned to }c\}.$$

Restricted copying statement. The minimum number of new shadow nodes is exactly $|A_c|$, excluding the descriptor itself.

Every affected terminal must be new: an existing immutable node cannot acquire a pointer to the fresh descriptor. Its parent must consequently be new to point to the changed terminal. Induction toward the root forces every node in $A_c$ to be new. Conversely, copy precisely this ancestor closure from the leaves upward and share every unaffected subtree. The resulting tree has all required current descriptors and exactly that many new nodes. Empty classes have empty closure and require no shadow change.

This proof uses an explicit dependency graph, not information size. Freshness is essential. If terminal outputs were merely preknown Boolean labels, one could not dismiss prebuilt alternatives by this argument. Likewise numerical addresses, allocation order and identity tests do not carry information in the reader: freshness is used only to explain why immutable old pointers cannot reference a newly created descriptor.

2. A dispersed-alias family defeats the direct repair

Take all binary owners of length $2k$ and let their class be their final $k$ bits. Every class has $2^k$ owners. For a fixed class, every prefix through depth $k$ is affected. Below depth $k$, there are exactly $2^k$ affected prefixes at each remaining depth. Therefore

$$|A_c|=\sum_{d=0}^{k}2^d+\sum_{d=k+1}^{2k}2^k=(k+2)2^k-1.$$

An owner has only $2k$ bits. No fixed multiple of its length bounds this direct shadow’s copying cost for all $k$. Literal preparation of the whole table is charged and may be large; it does not let immutable old nodes point to future fresh descriptors. Repeated future changes require fresh copies again. The conclusion is conditional on a bucket-descriptor change, not a claim that every idempotent activation changes a logical answer.

The family can index buckets by the $k$-bit suffix itself. These class labels are mathematical selectors, not free supplied native handles. If one insists on distinct physical length classes instead, preparing representatives can be much larger; that does not strengthen the result or remove its representation restriction.

This is a total-allocation failure. We do not infer a separate final-symbol lower bound. Even copying a single ordinary path has an eager root-rebuilding issue; the Lab’s capsule representation was designed to avoid that requirement. Applying this theorem to capsule trees would erase its central hypothesis.

3. The same family has a small shared selector

Discard the irrelevant first half of an owner in the current answer index. Store one descriptor at each terminal of a depth-$k$ suffix tree. All owner prefixes share that tree. The final $k$ owner bits identify its terminal, and an ordinary logical path-copy replacement uses $k+1$ new nodes rather than $(k+2)2^k-1$.

This is a semantic and logical-cost control, not construction 86. Recognizing the halfway boundary, checking the owner table, discovering and validating the factorization, routing the current source root, and implementing the endpoint through native capsules must all be paid. No decomposition, value of $k$, or ready suffix handle is supplied to a native machine by this example. A concrete uniform input-built implementation remains to be proved.

The contrast nevertheless rules out a tempting explanation: unbounded alias multiplicity alone is not the access obstruction. A shared quotient can collapse many owner paths while retaining all class distinctions. Reuse is cheap only if its current source-specific instance is accessible, not merely because a static class equivalence exists.

4. Dependent repairs examined and their remaining obligations

Stable indirection. Let every owner terminal point to one class record. In a mutable pointer machine, changing that record updates all aliases cheaply. Under immutable old-top semantics, copying the record leaves those aliases at the old version. Adding a current-version directory restores the original selection problem. Brodal’s shared mutable component controller in review 245 illustrates precisely the stronger operation required. This diagnosis is not an impossibility theorem for versioned indirection.

A root override for the latest changed class. Keep the old shadow and a bounded tuple of class/descriptor exceptions. A query can compare its selected class against that tuple, avoiding immediate copying. But repeated distinct updates eventually require either a larger tuple or installation in another current index. This is the same pending-overlay obligation exposed by assessment 244. Its descending-contraction witness only transfers if the new installer satisfies the same literal late-release assumptions. We do not transfer it automatically to a compressed override index.

A prepared quotient DAG. Sharing equivalent selector continuations avoids the tree-copy count, as the suffix control proves. However, arbitrary right tables need not have that particular quotient. A minimal semantic quotient is not itself an online construction algorithm, nor does it supply current source-version routing. Equivalence discovery, storage, update fanout in the quotient and traversal deadlines require a charged interface. We have not established that interface for arbitrary learned tables.

One cursor per possible current class. Retaining a growing list of prepared cursors does not put them in a bounded control tuple. Selecting the correct cursor still requires a route. A static template cursor is not automatically a cursor into the latest source-specific version. Earlier paid speculation may escape this diagnosis, but its workers, storage and selection must be explicitly bounded.

These attempts explain why simply copying the frozen selector shape into each current source is not the missing theorem. The surviving candidate combines shared selector behavior with an input-built current index; neither persistence alone nor a static quotient suffices.

5. Independent evidence and preserved controls

The independently authored checker uses immutable binary trees and a separate prefix-set oracle. Fresh execution passed 636 updates, 80,356 retained-snapshot reads, 23,130 closure-copy nodes and 76,260 comparisons against the suffix index. It exhausts all 256 two-class labelings of depth-three terminals and checks the suffix family for $k=1,\ldots,5$. It checks exact copying counts and semantic preservation, not native routing, preparation complexity or per-symbol timing. Revision integers stand for semantic test values; they are not native metadata operations.

Independent adversarial review supplied the closure proof and suffix escape, then emphasized three qualifications retained above: the fresh descriptor assumption, exclusion of capsule interpretation, and total copying rather than an unsupported final-symbol claim. The root analysis tested indirection, bounded overrides and prepared quotient variants against the prior current-version and service boundaries.

Construction 85 still handles local length-class reuse. Constructions 81–84 already demonstrate that maintained shared coordinates can avoid per-namespace updates. Replay charges each branch’s work; affine joins retain their coordinate contract; causal persistence preserves history without supplying a current selector; unary coherent consumers do not establish arbitrary branching composition. Entry 129’s imported bounds remain conditional matching/positive-path interface bounds with growing alphabets. None becomes a native lower bound here.

6. Handoff and integration disposition

Next, test an input-built quotient of selector continuations: ordinary right records must construct and check the factorization; each source must retain a current shared answer index; activation and late short-query routes must be streamed before their deadlines. Use the suffix family as a positive control, dispersed aliases as the direct-tree failure, and descending contractions as the late-insertion control. A native proposal must pin fixed degree/radius, finite labels/control, initialization, old-top updates, actual encoded length, every read/allocation, and final-symbol output. Preserve arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service as open.

This is a completed failed implementation assessment, not a new numbered native construction. Root CLAIMS.yaml is unchanged. The argument and finite evidence live together in GitLab; no primary PDFs or private scratch are published. Failure scope and reopening obligations are explicit above. The checkpoint and agenda retain the main selector target with this sharper test. Generated readable note/code projections are the Site representation; publication receipts, or any unfinished publication, are recorded separately in integration state. Homepage recency and publication ranking are unchanged.

Scheduled completion 151 counts this assessment once. Mathematical 148, native 85, window 2 and last reassessment 146 remain unchanged. Next 152 is research; primary review 155 and editorial 156 remain due. Installed reverse-writer retirement remains separate and unverified.