Shared foreign rows as independent reindexings

12 October 2026. Supporting argument and unsuccessful extension assessment. At this assessment, construction 77 remained unchanged. This is a smaller exact test for its open foreign-row mechanism, not construction 78 or a native-language lower bound.

Subsequent construction 78, construction 79 and construction 80 solve progressively broader structured subclasses. Arbitrary independent reindexings remain open. See the current checkpoint.

Outcome and payoff

A large foreign row need not be copied if a query can route directly to its source’s activation bit. But spelling both owners inside every target is already covered by the Lab’s query-side routing theorem, section 14.6. Repeating that construction would not advance the present frontier.

The remaining test can be stated as one activation set viewed through many independently prepared permutations. Every target still has two owners. Its ordinary prefix identifies the primary owner, while an arbitrary permutation inside that namespace identifies the foreign owner. Selecting one foreign store changes one answer in every namespace. Can those changes remain shared while every late named query finishes on its last symbol?

This formulation removes local omission machinery, arbitrary name lengths and arbitrary graph topology from the immediate test. It retains the difficult operation: accessing current source state through an input-built reindexing. A positive solution would extend reuse beyond bounded foreign scatter. The failed routes below identify obligations for such a solution; they do not prove that it is impossible.

1. An already completed escape

Section 14.6 fixes a finite family of subsequential maps from target names to predecessor names. The right input checks each actual incidence against those maps and stores its matching mask. The left input stores predecessor activation. During the late target pin, each map emits a bounded number of predecessor bits per actual symbol, driving an activation lookup alongside the static target-mask lookup. Exact final negation gives the Horn SAT answer.

For targets of the form $E(c)E(b)w$, with nonempty binary fields and $E$ the existing self-delimiting encoding, two such maps extract the two named owners. Output the fixed intermediate prefix, the owner’s encoded spelling and alias 0; the remaining target bits produce no output. Finite parsing handles validity and bounded final output. Partial parsers can be totalized on invalid words, while a finite-state syntax check rejects invalid right fields. The static mask is essential: a spelled candidate owner need not actually occur in a right record. Duplicate spellings cause no false membership.

Thus two explicitly spelled owners support unbounded incidence and unbounded selected stores through an established mechanism. The actual owner bits pay both traversals; there is no subsequent lookup or replay. This is a direct specialization of the earlier theorem, not a new construction. Encoding an arbitrary existing target this way is not free: it changes the language, literal identity and input length. It does not answer the open problem for unchanged target names.

2. An exact family with two owners

Fix $m\ge2$, put $h=2^{m-1}$, and let $W=\{0,1\}^{m-1}$. Choose a nonempty set $I\subseteq W$ of size $K\le h$. Primary store names are $c_i=0i$ for $i\in I$; foreign store names are $b_j=1j$ for $j\in W$. Every store name has length $m$.

For each namespace $i$, choose an arbitrary permutation $\pi_i:W\to W$. These permutations are represented by ordinary right incidences, not supplied as programs or free handles. Define

$$q_{i,x}=E(c_i)x\qquad(i\in I,\ x\in W).$$

Its length is $2m+2+(m-1)=3m+1\le5m$. Give $q_{i,x}$ exactly two owners:

$$c_i\quad\text{and}\quad b_{\pi_i(x)}.$$

Use construction 77’s ordinary right records (-01E(b)0,+1q);, one for each incidence. Give every store one nonempty contiguous group, in any chosen once-only order. Each primary store has $h$ targets. Each foreign store has $K$ targets, one in every primary namespace. All local rows are full rows, with alias 1 absent. The graph is the complete bipartite graph between $K$ primary stores and $h$ foreign stores. Changing the permutations changes its edge names, not this abstract graph.

The family is a collection of explicitly serialized test instances. No new claim is made that a native machine can validate arbitrary input as a complete permutation family at no cost. An eventual recognizer must state its accepted checked language and its own validation schedule.

Let $A_u\subseteq W$ be the foreign stores selected with alias 0 for source $u$, and $C_u\subseteq I$ the selected primary stores. Literal relation composition gives

$$M_u(q_{i,x})=[i\in C_u]\lor[\pi_i(x)\in A_u].$$

Indeed these are precisely the two possible intermediate witnesses. There are no other right incidences. The positive-source/negative-target Horn wrapper is SAT exactly when both terms are false. Restricting selections to foreign stores isolates

$$M_u(q_{i,x})=[\pi_i(x)\in A_u].$$

This is the independent-reindexing problem. A source update changes the common activation set $A_u$, and each query asks for one coordinate of its view through $\pi_i$.

Actual length

There are $2Kh$ right records. Let one source name $a$ have length $\ell$ and let $t$ actual left selections use that source. With the literal syntax inherited from construction 77, the encoded length is

$$N=2Kh(5m+13)+t(2m+\ell+13)+\ell+3m+12,$$

plus the actual fixed phase delimiters. The right-record term is $10+|E(b)|+|q|$; the left-record term is $11+\ell+|E(b)|$; both unit pins are included. Repeated selections count as actual records. No padding, supplied permutation, preparation after the right boundary or extra EOF time is present.

The right input is large enough to describe every chosen permutation. That does not grant later source updates extra time: one later selection has only $2m+\ell+13$ symbols. Its query likewise has only the literal source and target fields. The release time of source-dependent work matters as well as total $N$.

3. Which completed mechanisms cover this family?

The identity case $\pi_i(x)=x$ for all $i$ is already covered by section 14.6. One fixed parser extracts the primary name and another converts the suffix $x$ to foreign name $1x$, with the fixed intermediate syntax added. The matching masks distinguish actual incidences. Both owner degrees and the number of selected stores may grow. Therefore unbounded foreign degree by itself is not an obstruction to native recognition.

For arbitrary independent permutations, the following earlier sufficient hypotheses fail on suitable members of the family:

The mixed-prefix statement uses the actual observed support, so it does not rely on charging absent ambient names. With $m\ge2$, each namespace contains at least two suffixes. Its branching node is still mixed if unary paths are compressed. The statement rules out that fixed linear budget, not a different decomposition or shared predicate.

Fixed decoders cannot cover every input permutation

Fix any $k$ target-to-owner functions in advance, including any fixed family of subsequential decoders. Choose $h>k$, a namespace $i$ and a suffix $x$. At this one ordinary query $q_{i,x}$ the family predicts at most $k$ foreign names. Choose a name $b_j$ outside that set. There exists a permutation $\pi_i$ with $\pi_i(x)=j$; complete the remaining bijection arbitrarily. Its foreign incidence is not covered by the fixed family. Other namespaces may use any permutations.

The quantifiers matter: for every fixed finite decoder family, there is an input in this test family that it does not cover. This is not a claim that one particular finite instance defeats every possible hard-coded decoder, nor that input-built routing is impossible. The proof does not even use finite-state limitations. It identifies why the old fixed-family theorem cannot settle the whole new family merely by choosing more fixed routes.

4. Routes tried and the unresolved cost

Enumerate the foreign row. One newly selected foreign store changes $K$ target answers, one per namespace. Replacing the bounded packet by a list therefore releases $\Theta(Km)$ literal insertion work after only $O(m+\ell)$ input. Fixing the source length to $\ell=1$ makes the gap unbounded as $K/m$ grows. Delaying that list until EOF is disallowed. Keeping it as a raw pending row helps one last selection, but leaves the unbounded accumulation problem after many different stores are selected.

Maintain separate explicit answers in every namespace. Suppose the representation requires a distinct independently stored answer-bit cell for every pair $(i,x)$ and requires all these cells to be current before the next operation. It excludes shared activation indirection, lazy predicates, aggregate answer tags and precomputed alternative whole views. Changing $A_u$ from empty to $\{j\}$ changes exactly the $K$ coordinates $(i,\pi_i^{-1}(j))$. Under this explicit-output contract, at least $K$ answer cells must be installed or changed. For $K=h$ and fixed source length $\ell=1$, this exceeds every fixed multiple of a single selection’s length as $m$ grows. This is an output requirement of that representation, not a lower bound against all native storage.

Store one activation set and look up the permutation first. The semantic representation $(A_u,\pi_1,\ldots,\pi_K)$ is compact. But a literal target traversal that first exposes $\pi_i(x)$ at the last suffix bit leaves no time for a subsequent $m$-bit search of $A_u$. The encoded primary prefix supplies real earlier service, yet a proposal must explain which source-dependent continuations it prepares during that service. A total $O(m)$ host lookup bound does not supply the required per-symbol release schedule. The restricted factored-reader argument in assessment 224 explains this type of failure; its proof is not transferred automatically to every representation of this new family.

Share one materialized reindexing. If all $\pi_i$ are equal, the semantic views $\pi_i^{-1}(A_u)$ coincide. Reuse of one view could avoid $K$ copies. For arbitrary independent permutations those views need not coincide. Detecting and exploiting input-learned common structure remains legitimate, but semantic equality is not a free producer, classifier or query route. No native transfer from the earlier stored-substitution theorem is claimed without checking the complete wrapper and schedule.

Carry a source-key continuation. Fractional cascading suggests transporting a search position, but it does not provide immutable source-filtered bridges for this input. The permutations are known before activation; the activation set is not. All preparation before that point must remain useful for every later source version. Copying a changed source catalog into every namespace reintroduces the fanout problem. Following a frozen permutation into an unrelated current activation key reintroduces the release-time problem. These are the two costs that a successful bridge must avoid simultaneously.

5. The next decisive interface

Seek a query state that represents the residual predicate

$$x'\longmapsto[\pi_i(px')\in A_u]$$

after a suffix prefix $p$. The source pin and the ordinary $E(c_i)$ prefix must create its starting state with paid work. Each subsequent actual suffix bit must update only boundedly many local cursors and records; at exact suffix exhaustion the answer must already be available. A source activation must update the shared representation within its actual record, with a specified pending-work invariant if any.

This is an obligation, not a granted residual-predicate oracle. Its producer must use the ordinary right records. Charge every retained version, old-storage observation, allocation, name/pointer route and replay of consumed bits. Fix degree, radius, labels/control and initialization for one machine. Exclude identity, address, metadata and timing channels. No supplied graph, permutation code, ready handle or decomposition is allowed.

Every fixed number of namespaces, including two different input-built permutations, is already covered by construction 77 with foreign-packet bound $d=K$. Use fixed $K$ as a completed control, not another open target. The next test must let the number of namespaces grow. The decisive extension is a common current activation representation whose independently reindexed views stay accessible without update work proportional to $K$ or query work released after the endpoint. Structured permutation families may offer a useful intermediate criterion; a fixed decoder already covered by section 14.6 is a control, not another advance.

6. Evidence and status

The independent finite audit compares explicit right incidences and Horn closure with the activation formula, retains immutable source snapshots, checks identity-routing controls and counts the stated fanout/mixed-prefix witnesses. Host sets, dictionaries and permutations are semantic oracles. Finite checks do not establish a native execution bound.

The assessment record records the attempted constructions and independent review. This run yields a precise smaller frontier and avoids recounting the earlier routing theorem. It adds no native construction, substantive-result count, root claim or external novelty claim. Construction 77, the growing-alphabet entry-129 bounds and all earlier SAT/scaffold frontiers are retained.

Replay slices charge each traversal. Affine-fragment joins retain their specified coordinate-change operations; arbitrary input permutations are not automatically affine changes. Persistent causal sharing preserves versions but does not install the missing bridge. Unary coherent algebra supplies no general branching reindexing operation. Any eventual native recognition theorem would give a PEG for the reversal of its entire checked language, not automatically for that language itself.