A fixed normalization basis for independently learned views

Assessment 238, 13 October 2026. Written construction 82; independently reviewed. Extends construction 81, not the root claim ledger.

What changes

A namespace can choose its own exceptional cut length without owning its own activation index. The common representation removes initial zeros in one index and final zeros in another. At a fixed original width these operations are injective, even though their output lengths vary. Actual activation records update both indexes once. A query uses its namespace’s learned cut to produce the appropriate short key.

For example, at width $n=9$, one namespace may exchange $A_2(10)=000000010$ with $B_2(10)=101000000$; another may exchange $A_4(1010)=000001010$ with $B_4(1010)=101010000$. Removing trailing zeros from the two B owners gives 101 and 10101. The same trailing-normalized dictionary stores both, with distinct terminal markers even when one key prefixes the other. A leading-normalized dictionary handles the A owners. No activation is broadcast to the namespaces using those owners.

The payoff is a structural sufficient condition: growing families of views can share current answers when their owner decoders factor through a fixed, updateable set of injective normalizers, and the normalized keys meet the actual query deadline. A semantic factorization alone does not supply either operation. The construction below pays them explicitly and permits independently learned synchronous short-key maps as in construction 81.

1. Exact checked language

Use construction 81’s right-first ordinary Horn syntax, binary self-delimiting E, contiguous once-only store groups, known-store checks, alias semantics, primary/foreign support and late ordinary endpoint pins. Store names have a common input-learned width $m=2n+1$. Primary names c start in 0; foreign names are 1 alpha beta with $|\alpha|=|\beta|=n$. Targets are $q=E(c)az$ with $|a|=|z|=n$. Source names remain arbitrary. The first right record is foreign and supplies the inherited width bootstrap. There is no external header or decomposition.

Change the global ell of construction 81 into a local $\ell_c$ for every namespace with foreign support. The first foreign record for c must be an actual seed incidence

$$z=A_{\ell_c}(t)=0^{n-\ell_c}t,\qquad \beta=B_{\ell_c}(t)=t1\,0^{n-\ell_c-1},\qquad |t|=\ell_c,$$

with $\ell_c\ge1$ and $n\ge2\ell_c+1$. Infer $\ell_c$ from the number of beta positions preceding its last 1. Freeze these rulers only for c. Primary records may precede this seed at c; later foreign records there must use its frozen rulers. All namespaces share n, but their $\ell_c$ can differ and their number is unbounded. This order condition is part of the checked language, not a record-order invariance claim.

For each (c,a), the learned foreign alpha is $\sigma_c(a)$, consistent across all its incidences. The suffix decoder is

$$g_{c,a}(z)=\begin{cases} B_{\ell_c}(f^A_{c,a}(t)),&z=A_{\ell_c}(t),\\ A_{\ell_c}(f^B_{c,a}(t)),&z=B_{\ell_c}(t),\\ z,&z\notin A_{\ell_c}\cup B_{\ell_c}. \end{cases}$$

The two partial maps on $\ell_c$-bit keys are built from their actual incidences and are prefix-consistent: agreeing input prefixes of length j have agreeing output prefixes of length j. They need not be total, injective, inverses or equal. The first seed installs its identity-key A-to-B row. A and B remain disjoint for each c. Every foreign incidence must have $\beta=g_{c,a}(z)$, every primary incidence must have $b=c$, and exact original-name masks P(q),F(q) retain actual support. Missing or off-shape query targets have false membership; malformed input or invalid preparation rejects.

2. Two universal boundary normalizers

For $\beta\in\{0,1\}^n$ define $L(\beta)$ by deleting all initial zeros and $T(\beta)$ by deleting all final zeros; both map $0^n$ to the empty word. At fixed n, L and T are injective: prepend or append exactly enough zeros to recover length n. This injectivity would fail across different original widths. The common n is essential and is checked from input.

Every source u retains three roots:

$$I_u(b),\qquad J^L_u(\alpha L(\beta))=I_u(1\alpha\beta),\qquad J^T_u(\alpha T(\beta))=I_u(1\alpha\beta).$$

All foreign stores, not just exceptional stores, update both auxiliary indexes. Alpha has common length n, so concatenation introduces no split ambiguity. Variable-length keys use ordinary trie terminal values and preserve children. An empty normalized suffix is a terminal exactly at the alpha endpoint. Missing terminals mean false. Each triple represents the same completed left prefix, and prior triples remain valid.

For $z=A_\ell(t)$, the foreign owner has $\beta=B_\ell(f^A(t))$. Since B ends its nonzero prefix with a sentinel 1,

$$T(B_\ell(v))=v1.$$

For $z=B_\ell(t)$, its owner has $\beta=A_\ell(f^B(t))$, and

$$L(A_\ell(v))=L(v).$$

These identities hold for every admissible ell, including $v=0^\ell$. Thus foreign readout is

$$H_u(c,a,z)=\begin{cases} J^T_u(\sigma_c(a) f^A_{c,a}(t)1),&z=A_{\ell_c}(t),\\ J^L_u(\sigma_c(a) L(f^B_{c,a}(t))),&z=B_{\ell_c}(t),\\ I_u(1\sigma_c(a)z),&\text{otherwise}. \end{cases}$$

The product bit is $(P(q)\land I_u(c))\lor(F(q)\land H_u(c,a,z))$. Substitution of the actual owner proves both directions. Injectivity prevents an auxiliary activation from answering for a different owner; support prevents an unrecorded edge. Final output is the complement, the pinned Horn SAT answer.

3. Paid activation, including trailing deletion

During the literal source name u, open its three-root header. During E(b), check the known-store directory and update the full I path provisionally. For a foreign b, the alpha bits open both auxiliary paths. Leading deletion is streaming: skip beta zeros until its first 1, then descend on every remaining bit. At the record endpoint, close its terminal with true if alias 0; alias 1 restores all old roots.

Trailing deletion is not implemented by buffering a zero run and flushing it at the next 1. That would give an unbounded burst. Instead descend provisionally on every beta bit. At the alpha endpoint save the complete serial-capsule state: current subtree and root-to-tip ancestor FIFO. After each actual beta 1 replace this saved state by the current state. After a zero leave the saved state unchanged. At the endpoint, close the saved state with a true terminal, preserving that saved subtree’s children. Select this root only for alias 0.

The saved state is a fixed tuple of ready persistent queue and node references, not a copy of its path. Each traversal step reads the old dictionary, extends its immutable frame FIFO and may replace a root tuple. Closing one saved capsule requires bounded work by the established pointer-payload serial dictionary contract. No intermediate prefix is marked, so an early 1 does not activate the wrong shortened key. If beta has no 1 the initial alpha snapshot is chosen. Later provisional descent cannot change any saved subtree or queue version. The complete old dictionary is preserved outside the selected endpoint.

The resulting key is exactly $\alpha T(\beta)$. Induction on actual left records proves both auxiliary invariants. Each record updates a fixed number of paths (three) and snapshots at most once per beta bit. It never reads a namespace descriptor or enumerates views. Allocation and old-storage observations are charged to the actual literal input, including discarded provisional paths.

4. Learning and validating each local shape

The global width bootstrap is unchanged. A static c directory now has a finite initialized flag, its local unary rulers, and the inner a map. This is a fixed-arity payload. Its actual E(c) traversal exposes the descriptor before a arrives. An uninitialized descriptor is allowed for primary-only c; the first foreign record initializes it.

During E(c), split the already stored foreign name into the alpha and beta streams by the inherited n ruler. For initialized c, the following actual n a bits scan beta using its local rulers, preparing candidate short keys and exact A/B shape flags as in construction 81. For uninitialized c, the same n a bits instead infer $\ell_c$ and $n-\ell_c-1$ from beta’s last 1, using a unary position chain and a trailing-zero chain. Save the chain before each 1, reset the trailing chain there, and prepend one node at the end to obtain the $n-\ell_c$ ruler. This uses no arithmetic, subtraction or pointer comparison.

During z, a new namespace checks $\ell_c\ge1$ and $\ell_c\le n-\ell_c-1$ by parallel ruler traversal, then validates the actual seed A(t),B(t). For an initialized namespace run the ordinary identity comparison and two exceptional candidates. For each (c,a), its $Q_A,Q_B$ short program tries compare or install one output bit whenever the corresponding actual short input bit arrives. Only the final exact shape selects which provisional root and error flag matter. Ordinary z retains both old Q roots and requires $\beta=z$. The old/new alpha comparison also runs during z.

For a new namespace’s seed, keep beta’s original stream to compare its first $\ell_c$ bits with the final $\ell_c$ z bits. These same bits install the identity $Q_A$ row. No unknown local ruler is used before it is constructed. The unselected $Q_B$ lane may fail harmlessly. Different a values at the initialized c learn their maps through ordinary rows, without another seed or a separate shape.

Commit local rulers, alpha and selected Q roots, and support only after the full incidence succeeds. The c capsule remains suspended through a and z; the a capsule remains suspended through z. This is a fixed nesting depth with the same bounded closure as construction 81. Primary incidences compare $b=c$ and leave foreign metadata unchanged. The right/left boundary does no scan.

5. Final-symbol service

The source pin captures the coherent current triple. E(c) obtains the local rulers, inner a root and primary membership. Actual a obtains $\sigma_c(a)$ and $Q_A,Q_B$. While z arrives, run three foreign workers plus exact support and shape checks. Normalize each worker’s alpha traversal and initialization/switch to n+2 jobs. Each worker receives four jobs per actual z symbol; a larger fixed physical batch also performs the constant parser, map and output operations.

The ordinary worker then traverses n literal z bits, one released at each z symbol. This is the previous n+n+2 schedule.

The A worker reads $J^T$. Its $\ell_c$ transformed key bits arrive at the final $\ell_c$ z positions, one per position. The last position releases one additional sentinel 1. Since $n+2\le4(n-\ell_c)$, it has already traversed alpha and performed setup before these late bits begin. Each late position requires one job, except the last requires two, so the four-job budget finishes the entire key by the last z bit.

The B worker reads $J^L$. Its transformed bits arrive in the first $\ell_c$ positions. Its producer drops initial zero outputs and then queues every remaining output. This costs a finite flag and at most one released key bit per symbol. It therefore releases no more work and no later work than construction 81’s early $\ell_c$-bit schedule. The $n+\ell_c+2$ total and every release tail fit four jobs per symbol. If the transformed key is all zero, the selected terminal is the alpha endpoint.

After the last z bit, choose the completed answer using exact shape and support. A supported target guarantees the selected program path exists. Unsupported or wrongly sized target names may abandon incomplete workers and return false product membership. There is no EOF flush. The final ordinary punctuation pays the bounded terminal observation and Boolean complement.

6. A charged factorization criterion

Here is the reusable sufficient interface, separate from any claim of necessity. Fix K and a common checked owner universe U. Let $\eta_1,\ldots,\eta_K$ be injective key maps on U, each with a literal-update implementation that exposes a complete serial-dictionary endpoint in bounded work per owner symbol and bounded endpoint work. Exposing the endpoint may use a fixed tuple of persistent path snapshots; it need not emit the final key monotonically. The final selected endpoint must still denote exactly $\eta_i(b)$.

Suppose ordinary preparation builds and validates the view descriptors, support and programs within its own per-symbol budget. For every supported query its owner w has a factorization $\eta_i(w)=d_v(q)$, where the selection i and the key producer $d_v$ are available through paid literal routing. Require a fixed number of candidate readout lanes, each with a uniform per-symbol schedule finishing its key and terminal test by the actual deadline. Charge producer traversal, consumed-prefix replay, snapshot selection and all queues; an abstract equality or a scalar key-length bound is insufficient.

Then all views share K current dictionaries $J_i(\eta_i(b))=I(b)$. Each literal activation updates the K endpoints, and each query reads its already captured source version. Induction proves the invariant, and injectivity plus actual support proves exact membership. Fixed K and fixed local budgets compose through the simultaneous-record compiler. Initialization, discarded branches and retained history are included. This gives an update-and-readout closure condition, not an automatic extraction of such a basis from arbitrary views.

Construction 82 realizes it with the identity, L and T charts on the common fixed-width foreign owner universe. Primary owners are handled separately by I; they do not enter the auxiliary charts. The per-view shape descriptors and short programs are input-built and can grow without bound, whereas the update basis is fixed. In particular T’s last-1 endpoint snapshot is the stronger operation than a fixed subsequential output normalizer: an arbitrary zero run need not be buffered and re-emitted. It is still a paid local persistent operation. To see the distinction, compare arbitrary-length words $10^r$ and $10^r1$. Before the last 1 of the second word, an append-only output transducer cannot have emitted any of the r zeros: the first word has the same prefix and its correct output is just 1. The final transition and bounded final output cannot emit arbitrarily many zeros. This rules out a fixed subsequential realization of trailing deletion on all binary words; it does not rule out the persistent endpoint implementation. Shared boundary coordinates, rather than a growing collection of per-view indexes, are what make different exceptional widths affordable.

7. Resources, controls and remaining boundary

The actual encoded length N is exactly construction 81’s displayed length, with every repeated incidence, name bit and phase delimiter counted. Width and local-ruler discovery, static program construction, source routing, normalization, old observations, all allocations, queues and final output take $O(N)$ logical work/storage. The fixed-batch compiler has fixed degree, radius, labels/control, initialization and old-top semantics, with $N+1$ physical nodes after initialization. Pointer serialization takes $O(N\log(N+2))$ bits. One fixed automaton works for all n, all local $\ell_c$ and unbounded namespace/source counts. No supplied decomposition, advice, free ready handle, padding, uncharged preprocessing or EOF work is used. There are no pointer-identity, address, metadata or timing channels. The native-to-PEG consequence is for reversal of this exact checked language only.

Choosing every $\ell_c$ equal recovers construction 81’s base/short-map cases that also satisfy the new per-namespace seed order, including its sparse family outside every fixed construction-80 envelope-width contract. Construction 81 required only a global first seed; this is not inclusion of all of its accepted encodings. Different $\ell_c$ supply the present extension; the comparison is between sufficient contracts, not a lower bound for all native representations. Root claims and the imported catalog entry 129 theorems are unchanged.

The proof reuses serial capsules, strict persistent queues, provisional lanes and synchronous learned maps. Its added content is the shared injective boundary basis, paid trailing-endpoint snapshot, local seed producer and the normalized deadline calculation. This is a written extension of those methods, with no external priority claim. Completed replay slices, affine joins, persistent causal algebra and unary coherent cubical algebra retain their own contracts; no free external-heap join or arbitrary feedback closure follows.

The independent-per-namespace index route remains closed as a constant-update implementation. This construction reopens a structured family through a common basis. Both-side trimming, however, is not injective at fixed n: 00100 and 01000 both give 1. Reusing one Boolean key for them would answer true for an inactive owner after the other is activated. Restore a distinguishing coordinate with paid updates/readout, or prove a bounded-fibre alternative with its complete support contract; do not discard the coordinate silently.

The directly dependent test is an independently learned interior position. Section 8 below completes that test with the same basis and gives the surviving filler-word frontier.

8. Dependent corollary: learned interior positions

The same basis handles a further checked subclass without adding an activation root. This is a separate preparation contract, not permission to mix incompatible incidence rules without validation. Keep the literal syntax, common n, primary owners, learned alpha maps and exact support. Each namespace’s first foreign record is now a seed with

$$z=0^{n-\ell_c}t,\qquad \beta=0^{p_c}t0^{n-p_c-\ell_c},$$

where t has length $\ell_c$ and begins and ends in 1, $\ell_c\ge1$, $n\ge2\ell_c+1$ and $p_c\ge0$. The first and last 1 of beta uniquely determine $p_c$ and $\ell_c$. The actual seed participates in the relation. Later rows at (c,a) use a partial prefix-consistent $\ell_c$-bit map $f_{c,a}$:

$$g_{c,a}(z)=\begin{cases} 0^{p_c}f_{c,a}(t)0^{n-p_c-\ell_c},&z=0^{n-\ell_c}t,\\ z,&\text{otherwise}. \end{cases}$$

Later transformed keys may have leading or trailing zeros, or be entirely zero. Only the seed key has the two nonzero boundary bits. Different namespaces may have unrelated positions, lengths and short programs. The preparation producer checks this rule, and primary rows remain separate.

All local rulers are paid during the seed beta scan in the actual a field. Before the first 1, extend a unary p chain. From the first 1 onward, extend a second position chain and save it after each 1; its final saved length is $\ell_c$. Maintain an outside chain that grows with the initial zeros, resets to the saved p root at every 1, and grows on subsequent zeros. Its final length is $p_c$ plus the final zero-run length, hence $n-\ell_c$. A separate trailing chain resets to empty at each 1 and gives $n-p_c-\ell_c$. Save the beta FIFO cursor immediately before consuming its first 1, so the retained stream includes that bit. Every reset is root selection, not concatenation or arithmetic. During z, verify the seed, the first/last key bits and $\ell_c<n-\ell_c$ by bounded parallel ruler traversal. No first/last-1 search happens at the end.

For an initialized namespace, scan beta during a with the known prefix, key and suffix rulers. Require the two padding segments to be zero and retain the $\ell_c$ key bits. During the final $\ell_c$ z bits, compare or install the synchronous program outputs against that candidate stream. In parallel retain the full $\beta=z$ comparison. The final exact A-shape flag selects the appropriate provisional path and error condition. The seed installs its identity row. All c/a capsules and support commit together, at the same fixed nesting depth as above.

A supported exceptional query uses $J^T$. Its candidate path is alpha followed by $p_c$ zeros and the $\ell_c$ transformed key bits. Save the query cursor at the alpha endpoint before those zeros. After each transformed output 1, replace the saved cursor with the current cursor. At the deadline, observe the saved cursor’s terminal. This is a read-only counterpart of the trailing-update snapshot: it reads exactly $\alpha T(\beta)$. If the transformed key is all zero, the initial alpha cursor answers for the all-zero beta. Initial zeros before a later 1 remain part of that later saved path. No intermediate candidate Boolean is ORed into the answer.

The ordinary identity worker runs in parallel. For the exceptional worker, the initial alpha, setup and $p_c$ jobs satisfy

$$n+2+p_c\le 4(n-\ell_c),$$

because $p_c\le n-\ell_c$ and $3\ell_c+2\le2n$ follows from $n\ge2\ell_c+1$. These jobs all have paid ready rulers/cursors at the start of z. They therefore finish before its late key segment. Each of the last $\ell_c$ symbols then pays one map output, dictionary step and bounded cursor snapshot. The final selected terminal is ready without traversing any zero tail. A fixed enlargement of the physical batch implements the parser and snapshot operations around each normalized service job.

The source updates are exactly section 3, independent of every $p_c$ and $\ell_c$. The original triple suffices, though this corollary reads only I and $J^T$. It has the same $O(N)$ work/storage and native contract. If desired, the finite union of the two checked preparation languages is recognized by parallel fixed-many validators and controllers, with rejection unless at least one entire contract succeeds; it does not allow record-by-record switching. No new result counter is attached to this dependent corollary.

Thus arbitrary learned interior positions of zero-padded blocks are not the surviving obstacle. The earlier two-sided-trimming collision remains real, but its position can be retained in the trailing chart and traversed early. The next decisive test replaces common zero filler by independently learned filler words: seek a bounded shared normalization basis, charge pattern discovery and literal activation updates without scanning the growing pattern family, and prove timely current readout. Arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service remain open.

Independent finite audit · Review and evidence.