Learned filler words with a shared current-answer index

Assessment 241, 13 October 2026. Written construction 83. A sufficient checked subclass, not a general native lower bound or a new root admission.

Result and mechanism

Independently learned filler words can share one shortened activation dictionary. The dictionary stores a fixed-size bitmask at each short key. Preparation checks how many distinct actual stores have that key and assigns each a stable slot. Activating a full store changes its one slot; querying a supported target selects that slot from an already completed current lookup. No activation visits the namespaces using the store, and no matcher dispatches a list of matching fillers.

This changes an important hypothesis of construction 82: a normalizer need not be injective on every possible owner spelling. It can have enormous fibres globally, provided ordinary preparation checks a fixed fibre bound on the actual known stores. Section 18 of the earlier composition argument already supplies checked fibres and stable finite slots. The new construction combines that control with input-learned filler descriptors, synchronous short programs and timely current activation readout.

For example, at n=8 take the two suffixes 00111010 and 00111110 with the same alpha. Both parse as E(0) followed by a different four-bit filler. Their shared short suffix is 0011. With K=2, activating the first sets its slot while leaving the second slot false. Two namespaces can therefore ask through the same short path and still obtain different current answers. The actual full names and namespace seeds establish these slots and fillers.

Construction 83. For each fixed positive integer K, the exact language below has one deterministic native recognizer for all widths, namespace counts, learned filler words and source counts. Its ordinary preparation, activation and final query use bounded work per actual symbol. K is a machine constant; the filler words and widths are input data. A source has two current roots: its full owner dictionary and a shared shortened dictionary with K-bit terminals.

1. Exact checked language

Retain the ordinary right-first Horn syntax, binary E encoding, contiguous once-only store groups, known-store checks, alias semantics, exact original-name support and final pins of construction 81. Here E replaces each bit d by 0d and appends 11. The first actual right store is foreign, has odd width m=2n+1, and bootstraps the unary width rulers. Every store has width m. A primary store starts in 0. A foreign store is

$$b=1\alpha\beta,\qquad |\alpha|=|\beta|=n.$$

Every foreign store in this checked class must have a parsed suffix

$$\beta=E(v)w,\qquad v\ne\epsilon.$$

Parse aligned pairs 00 and 01 until the first pair 11; 10 before that delimiter, an empty v or a missing delimiter is invalid. After the delimiter w is arbitrary binary data. It may contain any pairs, including further 11 pairs. No contraction inequality is imposed on ordinary stores’ v.

Define the fixed parsing operation, with the input-learned alpha boundary,

$$\eta(1\alpha E(v)w)=\alpha E(v).$$

Require at most K distinct known foreign stores at each eta key. Repeated incidences of the same full store count once. This is a checked restriction, not a supplied partition. The fixed-width alpha prefix and self-delimiting E(v) make the short-key split unambiguous.

Right targets retain q=E(c)az, where c starts in 0, |c|=m, and |a|=|z|=n. Each namespace c with foreign support learns its own positive ell and filler w_c from its first foreign incidence. That incidence must be an actual seed

$$z=0^{n-\ell_c}t,\qquad \beta=E(t)w_c,\qquad |t|=\ell_c,\qquad n\ge4\ell_c+4.$$

Thus |w_c|=n-2ell_c-2. The filler is neither supplied separately nor prescribed in finite control. Primary incidences may precede the first foreign seed. Later foreign incidences must use the frozen local descriptor. Define A_c(t)=0^(n-ell_c)t. At each (c,a), learn an alpha value sigma_c(a) and a partial prefix-consistent ell_c-bit map f_(c,a). Every foreign incidence must satisfy

$$\alpha=\sigma_c(a),\qquad \beta=g_{c,a}(z)= \begin{cases} E(f_{c,a}(t))w_c,&z=A_c(t),\\ z,&z\notin A_c(\{0,1\}^{\ell_c}). \end{cases}$$

Prefix-consistency means that equal input prefixes of length j have equal output prefixes of length j. Maps may be partial and noninjective. The seed installs its identity-key row. Every primary incidence still has b=c. Exact support retains a primary flag P(q) and a foreign flag F(q); foreign support also stores a finite slot defined below. Invalid preparation rejects. Absent or off-shape final targets give false product membership through exact original-name support.

The arbitrary fillers are subject to the occupied-fibre restriction. In particular K+1 different fillers with the same alpha and encoded v are not admitted. This permits unboundedly many fillers across different keys and up to K at the same key. It is not unrestricted coexistence of every filler with every short key.

2. Stable slots from actual store spellings

Let B be the existing full-name known-store directory, extended by a finite slot payload for foreign stores. Let C be a preparation dictionary on eta keys with a count in 0,…,K. For a new foreign spelling b, assign

$$\lambda(b)=C(\eta(b))+1$$

and reject if this exceeds K. Increment that count and store the slot at B(b). For an already known spelling reuse B(b)’s slot without incrementing C. Slots never change. The controller tests occupancy of the exact spelling terminal, not pointer identity or a stored-name hash.

Induction on completed right records proves: within each eta fibre, distinct known owners have distinct slots; repeated spellings retain their slot; every occupied slot identifies one full owner. Different fibres freely reuse slot numbers. This is the section-18 finite-fibre argument applied to owners rather than final targets. The old contiguous-group legality check remains a separate condition; slot reuse does not authorize reopening a closed store group. Its flags and the foreign slot share one full-name capsule: capture the old slot-presence before any provisional group change, and commit group and slot fields together. A newly created group marker is not mistaken for a previously assigned slot.

All registration fits the existing record. During E(b), retain b in a strict persistent FIFO and open its full-name capsule, preserving its old occupancy and slot. The first b supplies the n ruler only at its end. Therefore, uniformly for every row, replay the retained b during the actual E(c) field. Its decoded c length is m, and its actual encoding has 2m+2 symbols; a fixed replay rate processes all m retained owner bits, the eta parser and bounded setup before E(c) ends. The same scan prepares alpha and beta streams. A malformed or short c may abandon provisional work and reject.

During replay, open C along alpha and E(v), then stop its key descent at the internal delimiter while validating and consuming the entire remaining beta. At the end of E(c), the old B occupancy and the C count determine the new slot. Keep both capsules suspended and commit them only when the incidence succeeds. Suspension carries paid immutable paths, not free arrays. The simultaneous c-directory and support paths add only fixed-many capsules. No scan occurs at the right/left boundary.

This version requires no comparison of two stored filler words to establish fibre membership. Exact full-name lookup distinguishes owners; the fixed parser computes their common short key. It also counts ordinary identity owners, not just stores appearing as exceptional images.

3. Learn and validate fillers within ordinary records

During a, scan the saved n-bit beta stream, while opening the inner a map. For an uninitialized c, the pair parser builds the ell ruler, saves decoded v in a FIFO, and saves the remaining w as the candidate filler. Build the n-ell ruler by appending one cell for the first bit of each code pair, none for its second bit, and one for every delimiter and filler bit. For the first 1 of a potential delimiter append a cell immediately; append another for its completing 1, rejecting 10. Thus no lookahead is needed. Its length is exactly n-ell. Build a second ruler of length 4ell+4 using four cells per decoded code bit plus four fixed cells. These are fixed local batches, not arithmetic on an unbounded register.

During z, compare the 4ell+4 ruler with a fresh n ruler and reject unless the former fits. Check the seed’s initial n-ell zeros, then compare its final ell bits to the saved decoded v. These actual bits also install the seed’s identity program row. Freeze the descriptor only after success. Nonempty v and exact beta length were already checked. No search for the delimiter or filler is deferred to the end.

For an initialized c, the beta scan during a checks an exceptional candidate E(v)w_c: exactly ell code pairs, the delimiter, then equality with the frozen filler FIFO, including exact exhaustion. It prepares the decoded ell-bit candidate v. A wrong shape or filler sets a provisional exceptional error. The full original beta stream remains available for the identity comparison during z.

During z, run the identity comparison in parallel with the A_c-shape check and short-program builder. In the last ell positions, descend the input t path and compare or install one output bit from v at each step. Shared program prefixes must agree. At the endpoint, an A-shaped target selects this candidate and its errors; other z select beta=z and leave the short program unchanged. Alpha consistency is checked over z as in construction 82. Primary rows compare b=c and do not initialize or alter foreign metadata.

After all validation, store the finite owner slot with F(q). Repeated foreign support must agree on the slot. In fact the checked alpha, local filler and functional short map determine a unique full owner for q; the comparison guards the implementation explicitly. Commit support, descriptors, program, known-store slot and fibre count as one fixed-depth provisional transaction. A failed whole input never contributes a usable prepared representation.

4. A constant-size current summary at each short key

For each source u, retain the immutable pair (I_u,J_u). I_u is the full activation dictionary. The shortened terminal J_u(k) is a K-bit mask, initially zero, satisfying

$$J_u(\eta(b))[\lambda(b)]=I_u(b)$$

for every known foreign owner b. Unoccupied slots remain zero. Both roots describe the same completed left prefix.

During the literal source name, open its header. During E(b), check the full known-store path and provisionally update I. For a foreign b, open J along its actual alpha and encoded v. At the internal 11 delimiter save its complete endpoint capsule. Consume and validate the remaining full owner spelling without extending this J path. At the actual full-name endpoint, the frozen B terminal supplies lambda(b). Change that one bit of the saved mask to true. Closing a saved capsule preserves other mask bits and unrelated children and has the established bounded endpoint cost.

The alias is read afterward. Alias 0 commits the two marked roots; alias 1 restores the old pair. Primary owners change only I. Unknown stores or malformed names reject. The known-store check validates the entire filler even though J’s traversal ended earlier. No view descriptor is consulted and no match report is emitted. All provisional path allocations and discarded roots remain charged.

The invariant follows by induction. Only the activated owner’s slot changes; occupied-fibre injectivity excludes interference with another owner. Repeated activations are idempotent. Old source pairs retain their old answers. K-bit manipulation is finite control for fixed K; it does not encode a growing mask in one unbounded label.

5. Timely readout, including late slot selection

The positive pin captures the current pair for its source. During E(c), obtain the namespace descriptor and primary answer I_u(c). During a, obtain sigma_c(a) and the short-program root. In parallel the exact support reader traverses the full ordinary target. At the beginning of z, start two foreign workers:

• The ordinary worker reads I_u at 1 sigma_c(a) z.
• The exceptional worker reads J_u at sigma_c(a) E(f_(c,a)(t)), for an A-shaped z.

Each worker receives four normalized service jobs per actual z symbol. A job includes bounded stream, queue and dictionary operations; the fixed physical batch separately covers parser, producer, support and finite mask operations. Initial alpha traversal and setup cost n+2 jobs. The ordinary worker has the inherited n+n+2 schedule.

For the exceptional worker,

$$n+2\le4(n-\ell_c),\qquad n\ge4\ell_c+4.$$

Hence alpha and setup finish before the last ell_c input bits. Each short-map output bit releases its two E-code bits. The last output also releases the two delimiter bits. Every late symbol therefore releases two jobs, except the last which releases four. They all finish on their releasing symbol. No filler bits are traversed by this worker, and no final output flush is required.

At the deadline, A-shape selects the exceptional mask; the actual foreign support payload supplies lambda and selects its bit. This late selection starts no path traversal. Otherwise the ordinary worker supplies the foreign bit. Exact support gives

$$M_u(q)=(P(q)\land I_u(c))\lor(F(q)\land H_u(q)).$$

For a supported exceptional target, the prepared owner b obeys eta(b)=sigma_c(a)E(f(t)), so the invariant makes the selected mask bit exactly I_u(b). The ordinary case reads the complete actual owner directly. Conversely each support flag denotes an actual right incidence. Thus M is precisely relation-product membership, and its complement is the pinned Horn SAT answer.

A missing source has zero roots. An absent target cannot borrow another target’s slot: its F flag is false. An uninitialized primary-only namespace disables its exceptional worker. A missing map path makes only that candidate unsupported. Ill-sized final targets may abandon workers when exact support is false; malformed overall syntax rejects independently. The final ordinary punctuation pays the bounded Boolean observation and complement. There is no EOF work.

6. Resource contract and useful separation

The actual length is the inherited literal length

$$N=\sum_R(10+e(b)+|q|)+\sum_L(11+|u|+e(b))+11+|s|+|t|,$$

with e(b)=2|b|+2 and actual phase delimiters also counted. The interior E(v) is part of the ordinary binary owner name, not an added work field. Every filler bit is genuine name data and is counted during preparation and activation. The fixed replay during E(c), all descriptor discovery, collision counting, old-storage observations, provisional allocations, name routing, queues, output and retained histories cost O_K(N) logical work and records. Binary pointer serialization costs O_K(N log(N+2)) bits.

Use exactly the established simultaneous-record compiler: finite labels/control, fixed degree and radius, fixed initialization, observations from the old top, and N+1 physical nodes after initialization. All live root tuples have fixed arity for fixed K. Neither n nor ell nor w_c is compiled into finite control. One machine works for all admitted inputs at that K. There is no advice, supplied decomposition, ready handle, padding, uncharged preprocessing, EOF work, address comparison, pointer-identity test or timing channel. Native recognition implies a PEG for reversal of this complete checked language only.

This is a separate sufficient language, not literal inclusion of construction 82’s zero-padded encodings. Its new flexibility is unrestricted learned filler contents and input-checked finite owner fibres. For a simple unbounded family, choose distinct n-bit alpha prefixes for namespaces, ell=1, both short inputs, arbitrary fillers of length n-4, and identity short maps. Each fibre has one owner even when the number of different fillers grows with n. More generally, up to K different fillers can share a given alpha and short key, with slots preventing collisions. The fillers need no common period or finite catalogue.

The representation explains the escape from per-pattern dispatch: the short key is computed by one fixed parser, and activation uses its store’s stable slot. It never discovers which namespace patterns match. This does not solve arbitrary learned shortening rules or unboundedly many independent owner bits at a single short key.

7. Failures, dependent extension and next target

Ignoring slots is unsound. Let two known owners have the same alpha and E(v) but different fillers. Activate only the first. A Boolean J entry would answer true for a supported target of the inactive second. The K-bit mask repairs this when K is fixed. With K+1 distinct owners, this representation rejects during preparation. Neither fact is an unrestricted native lower bound.

The fixed-K construction is the directly dependent extension of the injective case K=1, completed here rather than left as a separate result. Full-name duplicate reuse, stable slots and late finite selection are inherited controls. The added argument is the paid owner-side registry, learned-filler producer and short-program readout tied to one current activation mask. This is a written extension of established Lab methods, with no external priority claim.

The next decisive target is to allow unbounded occupied owner fibres with a checked shared answer representation. Independent activations can distinguish every owner in a fibre, so collapsing their bits into one Boolean answer is invalid. Seek a paid shared inner index whose selector is learned from ordinary records and can be accessed before the final symbol; avoid per-namespace updates and a final traversal initiated by a late selector. Arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service remain open. Previous entry-129 state/port bounds and all SAT/scaffold controls retain their exact scopes.

Finite audit and review separate semantic computation from the written native schedule.