Bounded ownership does not supply timely source access

12 October 2026. Supporting arguments and an unsuccessful extension attempt after construction 76. No new native recognition theorem, root admission or external priority claim.

Construction 77 subsequently supplies a routed-owner and bounded-foreign-scatter escape. The arbitrary-name access problem and the restricted-reader obstruction below retain their stated scopes.

Outcome and the missing operation

A target belonging to at most two stores has only two possible owners, but those owners need not become usable early enough. Ordinary right input can build an inverse directory of owner names. A final query can traverse that directory and still finish before the source-specific state of either owner is accessible.

The distinction survives equal name lengths and unique ownership. In the factored representation analyzed below, reversing target bits gives an owner key that cannot be used to search the source’s activation trie within a fixed per-symbol deadline. This is a failure of that representation and readout contract. A native machine that prepares a different aggregate can escape it.

The investigation therefore does not extend construction 76 to arbitrary overlapping stores. It does discharge the owner-name discovery step and isolate a stronger next target: prepare source filtering together with the query route, rather than discover a key at the query’s endpoint and charge a second lookup afterward.

1. An input-paid inverse owner-name directory

Use construction 76’s overlapping-target syntax and once-only contiguous store groups. Fix an ownership bound $d\ge1$. Within each store, local aliases and target names have its learned widths. The existing local producer maintains exact support membership and reports whether an incoming target is a new local birth.

Add a persistent literal dictionary $I$ keyed by target word $w$. A leaf holds at most $d$ retained store-name streams. During the actual target bits, traverse and prepare the path in $I$ in parallel with the local producer. At the endpoint:

• On a duplicate within the current store, retain the owner list unchanged.
• On a new local birth, append the current store-name pointer; reject if this would exceed $d$.

Why is no long owner-name comparison needed? The current store occurs in one contiguous group and never reopens. A target’s first local birth is its first ownership insertion for that store. Every pre-existing entry therefore belongs to an earlier, distinct store. Subsequent appearances in this group are filtered by the exact local birth flag. This proves by induction that the leaf list is exactly the distinct owners seen so far.

The current name was retained during its actual encoded prefix. Appending a pointer is a fixed-size endpoint operation; the target-name path has already been traversed and its coherent writeback capsule is ready. The work and allocation are $O_d(|w|+1)$ per record, with fixed degree/radius inherited from the local dictionary primitives. All encoded store names and their routing remain charged by construction 76. No supplied incidence directory or endpoint-length lookup is used.

This proves a charged owner-NAME preparation step, not a complete recognition theorem. In particular a pointer to the current store name is not a pointer to its final frozen tuple or to a lane of a future selected source.

2. Why the obvious continuation is unpaid

The proposed readout was: route through $I$ using $q$, retrieve at most two owner names, find each owner’s lane in the selected source, and run those local readers. The last two operations do not follow from the first. A name first exposed at the end of $q$ supplies no remaining symbols to pay its source-directory lookup or local query replay.

Nor can owner leaves simply point to the final store tuple during their creation. That tuple depends on later records in the group. Immutable old nodes cannot be patched at the group’s end. A mutable forwarding cell would change the model. A separate directory of final roots remains legal, but its lookup must be paid too.

Short owner codes remove one possible length mismatch, but not the release-time problem. For each fixed target width $n$, nonempty stores with overlap at most $d$ satisfy

$$s_n\le d\,2^n.$$

Indeed each such store contributes at least one store-target incidence, and each of the $2^n$ possible words contributes at most $d$. This suggests codes of $O(n)$ bits inside a width class. It does not construct a native cross-class code allocator, and a code delivered only at the query endpoint is still too late for an $O(n)$ traversal. The next argument grants suitable short codes and shows that this issue remains.

3. A precise factored-reader obstruction

Consider the following restricted interface. A source’s activation bits occupy the leaves of an immutable complete binary trie of depth $n$, keyed by owner code. Interior labels and topology contain no activation aggregate. The target-to-owner dictionary contains no source-specific pointers. The only edges into activation data are the trie root and handles obtained by actual traversal. There are no history/backbone edges, address tests, metadata channels, timing channels, cached terminals or activation-dependent initial control outside this contract.

The charged source-pin/query phase starts with only the activation-trie root, together with activation-independent owner data. No deeper activation handles from construction are initially retained. Grant the reader free retention and later access to every activation node observed during this charged phase. This is stronger than a fixed number of pointer registers. Nevertheless, charge at most $C$ activation-node observations and at most $C$ local traversals per actual input symbol, each traversal crossing at most $r$ edges. A fixed amount of source-pin/header service is absorbed into a constant $c$. The reader must output by the query’s last symbol. Only observed leaf bits can influence its activation-dependent state.

Let target $q\in\{0,1\}^n$ have the unique owner code

$$b=\operatorname{rev}(q).$$

The owner code is no longer than the query. Even grant the reader the reversal rule for free. For arbitrary activation vectors, no fixed $C,r,c$ satisfy this interface’s deadline for all $n$.

Cut proof. Answer all observations with the all-zero activation vector. Fix a query prefix $z$ of length $n-t$. Its $2^t$ completions have owner keys

$$\operatorname{rev}(y)\operatorname{rev}(z),\qquad y\in\{0,1\}^t.$$

There is exactly one candidate owner leaf in each depth-$t$ subtree. Before the remaining $t$ symbols arrive, at most $B=C(n+c)$ activation nodes have been observed. Mark a candidate subtree if any node strictly below its depth-$t$ root has been observed. Each observation marks at most one subtree. Choose

$$t=\left\lceil\log_2\bigl(C(n+c)+1\bigr)\right\rceil.$$

Then $2^t>B$, so some candidate subtree is unmarked. Choose the completion whose owner lies in it. Even grant the reader a free handle to that subtree’s root: there is no previously observed deeper node in it. During the remaining symbols, traversals can advance depth by at most $rC(t+c)$. For sufficiently large $n$,

$$n-t>rC(t+c).$$

Thus the candidate leaf cannot be observed by the deadline. Flip just its activation bit to one. All observed data, control choices and the complete query are unchanged, but the required membership answer changes. This contradicts exact readout under the stated contract.

The proof includes speculative traversal: it charges every subtree entered before the cut, and grants arbitrary access to already observed nodes. It does not exclude useful work merely because it was speculative. It does exclude source-specific shortcuts and uncharged information about unobserved leaf bits; permitting those is a different representation.

A Horn realization of the interface bits

For each $q$, prepare the store named $b=\operatorname{rev}(q)$ with its sole observed alias 0 and sole target $q$. These stores have equal target width $n$, local alias width one and unique ownership. For a single source, select alias 0 in a store to encode activation one, or the absent alias 1 to encode zero. Mention every store, so the selected-lane key set can remain fixed. Each store’s observed row has zero omissions.

This realizes independent activation bits and the exact membership question used above. It does NOT force a native recognizer to retain the factored activation trie. The lower bound concerns that explicit representation and query interface, even on these simple instances. It is not a lower bound for this Horn language, for construction 76, or for general scaffolding automata.

4. A paid escape on the singleton control

The same singleton family admits a simple alternative schedule when all store names and targets have the common width $n$. Retain, for each source, a target-keyed committed membership trie and one pending selected target or EMPTY.

During the next actual store-name prefix for that source, its $n$ decoded bits pay insertion of the preceding pending target into that source’s target trie, while the ordinary store lookup runs. The newly selected singleton target becomes pending after the local alias. It is already retained in that store’s tuple. No traversal of its entire name begins at the alias endpoint. An absent alias installs EMPTY after the old pending work finishes.

The final query reads the committed target trie and compares with the one pending target in parallel. This is the inherited pending-reader schedule specialized to singleton stores; it is a control, not another numbered native construction. Literal source names still pay source retrieval and writeback, all targets come from ordinary right records, and retained versions remain immutable.

This escape matters: the factored obstruction is about where the source-dependent bits are stored. It does not assert that reversing a key intrinsically defeats native recognition. Materializing one singleton per selection is affordable here. For a general locally dense row, one short selection can represent arbitrarily many targets; the singleton materialization schedule cannot simply enumerate that row. Sharing it instead returns to the unresolved routing problem.

5. Routes tried and their exact limits

These failures concern the specified implementations, not every possible representation. In particular no information-size bound is substituted for access cost. A prepared aggregate, prefix-synchronous source index or another input-paid route remains a legitimate escape.

6. Next test, controls and evidence

The next target is a source-filtered query route for arbitrary names and ownership at most two. Require a concrete release schedule: as a query prefix is read, at most a fixed number of candidate lane states must become accessible early enough that its remaining symbols pay the remaining lookup and literal-readout work. Each released continuation must either already have processed the consumed query prefix, or leave enough actual suffix service to pay source routing and replay of that prefix while keeping up with new arrivals. Prove that the original records build and maintain this property, or produce a precise obstruction to that construction. A semantic list of two owners or a length bound on their codes is insufficient.

The next dedicated primary-proof review should compare online prefix routing and persistent multi-index access under this release-time contract. Reassess the singleton materialization escape and construction 76 before proposing a broader lower bound. No new literature review is claimed here.

Replay still pays each traversal. Affine-fragment joins retain their coordinate hypotheses. Causal sharing preserves versions but does not backpatch final roots. Coherent unary algebra does not supply a source-filtered branching index. Native SAT controls retain ordinary late pins and the final-symbol deadline. Imported entry 129 retains its growing alphabet and conditional state/port scope.

The independent finite audit checks owner discovery, duplicate suppression, bounded ownership and the stated restricted readout/control examples. It is a finite semantic check, not native execution. Assessment 224 records its exact scope, review and disposition. At assessment 224, construction 76 was the latest completed native result. This unsuccessful extension and its supporting arguments did not create construction 77; the later construction linked above uses a different restricted interface.