Learned suffix programs can keep one current activation dictionary

13 October 2026. Written native construction 79. A charged composition of construction 78 with bounded-delay prefix readout, using the Lab’s established capsule dictionary, strict FIFO and simultaneous-record compiler. This is a sufficient subclass theorem, with no root admission or external priority claim.

Result and motivation

A growing family of independently prepared namespaces can change both halves of a target suffix while sharing one current source-activation dictionary. The first half may select an arbitrary learned replacement. The second half follows a program learned from the actual right records, with a fixed bound on how late each output bit becomes available. Its meaningful input symbols pay for both the delayed first-half lookup and the transformed second half. An activation never visits every namespace.

Construction 78 required the second half to remain unchanged. Here it can undergo a different learned transformation for each namespace and first-half key. The program is a prefix trie built from examples, not a supplied state graph. Its size may grow with the input; the delay bound belongs to one fixed machine.

1. Exact checked language

Keep construction 78’s entire ordinary right-first Horn spelling, phase delimiters, common store width $m=2r+1$ with $r\ge1$, once-only contiguous store groups, left validation, aliases and late endpoint pins. Right targets have the literal form $q=E(c)az$, where c begins with 0, $|c|=m$ and $|a|=|z|=r$. E encodes a bit e as 0e and appends 11. A primary store must equal c. A foreign store has the decoded form $b=1\alpha\beta$ with both halves of length r.

Fix an integer $d\ge0$ in the machine. Replace construction 78’s condition $\beta=z$ by these two conditions on actual foreign right incidences:

1. At a fixed pair (c,a), every record has the same alpha, as before.
2. For records with that pair and suffixes z,z’, whenever z[:j]=z’[:j] with 1<=j<r, their beta prefixes of length max(0,j-d) agree. If z=z’, their complete beta words agree.

Here x[:j] means the first j bits, not an operation supplied to the native machine. The second condition is a bounded-delay prefix-consistency test. The final equality makes a partial function $\tau_{c,a}(z)=\beta$. It does not demand injectivity, totality or completion of missing records. Duplicates are allowed. Every target still has at most two distinct owners, its actual primary and one foreign owner.

The accepted words are exactly the structurally valid formulas satisfying these conditions whose pinned Horn formula is satisfiable. An absent, incorrectly shaped or incorrectly sized final target denotes false product membership rather than invalidating an otherwise valid formula. Structural defects in the right or left blocks reject.

For example, tau can be a different input-built prefix-tree automorphism at every (c,a), already with $d=0$. With $d=1$, swapping adjacent suffix bits, leaving a final unpaired bit in place, is allowed: its first output bit needs the second input bit. Such transformations need not be fixed in the controller. Arbitrary reversal of unbounded suffixes does not meet any fixed delay bound on the full domain.

2. Data-built local program and exact representation

At each (c,a), retain an alpha stream and a binary suffix-program trie Q. A node reached after j suffix bits stores a finite output chunk:

• for j<r, it is empty if j<=d and otherwise the one bit beta[j-d];
• for j=r, it contains all beta bits not emitted earlier, at most d+1 bits.

Bit indices in this description start at one. Since r is common to the whole input, a given depth is never both an internal emission step and a terminal step. Every node’s chunk is determined by the prefix-consistency contract. Conversely equality of these chunks on every shared path implies that contract. At depth r the concatenation of all chunks is exactly beta. An occupancy flag distinguishes an uninitialized node from a valid empty chunk; a terminal flag records an actual complete suffix.

Use finite labels for chunks of lengths at most d+1. There are only finitely many for the fixed machine. No input-dependent integer or unbounded word is packed into a label.

Retain the actual primary and foreign support bits P(q), F(q) from construction 78. For source activation dictionary B_u, the invariant is

$$M_u(q)=(P(q)\land B_u(c))\lor(F(q)\land B_u(1\sigma_c(a)\tau_{c,a}(z))).$$

A missing source, map or program path gives a false term. Actual foreign support guarantees all its required program data. This is exactly the right-relation witness decomposition: consistency identifies the unique foreign spelling, while support guards prevent a learned map from inventing unrecorded incidences. Noninjective maps and sparse tables cause no problem.

3. Producer: build and check during the ordinary right record

Use the pointer-valued serial capsule dictionaries and their internal-payload update rule from sections 12 and 16 of the native reader. A builder changes its current node payload before its next descent, so its saved frame already holds the change. Its endpoint closes a capsule in bounded work without an upward traversal. No mutable backpatch or program compilation pass is used.

Build the full-width and half-width unary rulers from the first actual store field exactly as in construction 78. While a foreign b arrives, prepare the stream alpha beta after its leading 1. During the following E(c), transfer r leading bits to the alpha FIFO, leaving beta in the original FIFO. This finishes before a begins. In parallel parse and check c, open the outer namespace capsule, and traverse the actual target-support builder.

During a, open the inner D(c)(a) capsule and obtain its old payload (alpha stream,Q root), defaulting to absent. Keep both outer and inner paths suspended. Do not close an alpha-only payload and thereby lose the pending program update. Preserve the old alpha for comparison; retain the new alpha separately.

During z, compare old and new alpha one bit per symbol when an old value exists. Also open the old Q path along the actual z bits. A finite counter saturating at d tracks the initial delay; a fresh half-ruler cursor detects the last valid suffix bit. At a nonfinal depth j, pop the next beta bit exactly when j>d and use it as the chunk, otherwise use the empty chunk. At the last depth, pop the remaining at-most-d+1 bits into a fixed tuple. The beta FIFO has exactly r bits because b’s width was already checked. For short $r\le d$ the final chunk is the entire beta, still bounded by d.

At each reached Q node, compare its stored chunk with the candidate chunk if occupied; reject a disagreement. Otherwise install the chunk and occupancy flag in the current builder payload. Preserve existing children and terminal flags. Set the terminal flag at the full suffix. At the delimiter check exact target width, alpha equality and beta exhaustion, then close Q, install (new alpha,Q) in the suspended inner capsule, and close inner and outer capsules. These are three bounded-cost capsule closures; the retained paths may have unbounded depth. Commit the resulting root and support flag together. Primary records leave D unchanged and follow construction 78’s primary validation.

Thus every record checks consistency against all earlier records at its literal prefixes, including records in other store groups. Repeated identical records leave the semantic program unchanged. A later conflict rejects; provisional immutable records are abandoned without rollback. Each bit performs a bounded amount of work depending on d, and all terminal operations are bounded independently of r and table size. No endpoint enumeration, graph minimization, name-equality-by-address or ready program handle is assumed.

4. Current activations and the query pipeline

Left records update only B_u, using their actual source and decoded store bits and alias 0/1, exactly as in construction 78. The static D and Q structures are not touched. Each source and retained version remains separate. The positive pin obtains the selected current B_s through its actual source spelling.

During E(c), look up D(c) and read primary activation B_s(c), while traversing the static support trie. During a, look up D(c)(a). At its end, the alpha stream and Q root are ready. Initialize the foreign activation cursor at B_s’s child 1. There are no old namespace-specific activation roots to refresh.

During each z bit, one lane advances Q and enqueues that node’s chunk in a strict persistent FIFO. A second lane performs a fixed number $C=d+4$ of normalized worker steps after that enqueue. The worker first traverses alpha in B_s, then the emitted beta bits in order. Normalize setup and the stream switch as two extra worker steps. A normalized data step comprises one ready stream pop and one activation-dictionary advance; the inherited fixed-batch compiler absorbs its constant primitive cost. The producer also gets its own fixed local batch, including the final chunk of at most d+1 bits. Missing program paths disable the foreign lane.

The last suffix bit, detected by the learned ruler, releases the bounded final chunk. It is serviced on that actual bit, not after the word. At the ordinary target punctuation observe the ready terminal activation mark and actual support flags; by the final semicolon output the Boolean complement of the primary/foreign OR. Underlength and overlength targets have false exact support, so their unfinished foreign worker may be abandoned. No query-time structural rejection or free EOF flush substitutes for the SAT answer.

5. Release-time proof, including the final burst

The schedule must pay more than a total-work bound. Number the r actual suffix symbols 1 through r. Alpha’s r steps and the two stage steps are available from the start, subject to serial order. Output bit i of beta is released at

$$\rho_i=\min(i+d,r).$$

For $d=0$ this means one output bit on each suffix symbol. For d>0, the last symbol releases the remaining bounded tail. The earlier ordered deadline criterion applies to this fixed-order worker, with ingestion before service.

A tail starting among the initial alpha or stage tasks has at most 2r+2 steps and r service symbols, and 2r+2<=4r<=Cr because $r\ge1$. A tail starting at beta bit i has r-i+1 steps. Put L=r-rho_i+1>=1. Then

$$r-i+1\le L+d\le(d+1)L\le CL.$$

Every release tail therefore fits its available slots. The ordered worker finishes by the last suffix symbol. Dependencies do not make the proof assume early service: setup, alpha and switch remain explicit preceding tasks, and the criterion accounts for their serial interference. A missing activation-trie path may be treated as an absorbing zero cursor; continuing nominal work only makes this upper bound conservative.

No release schedule is supplied to the runtime. Ruler exhaustion and finite delay control generate the chunks during actual input. The mathematical inequalities certify the implemented service discipline.

6. Native resource theorem

Theorem 79. For every fixed $d\ge0$, one deterministic native scaffolding automaton recognizes exactly the checked satisfiable language in section 1. Width, namespace count, program size, source count and store count may grow. All source activations are retained once per source, rather than copied across namespace views.

The representation identity proves semantics. The producer proves that the required program and consistency checks are paid by the right block. The left phase maintains exact current activation; the release-tail proof supplies every valid query answer by its endpoint. Malformed input is recognized with the same rulers and finite phase checks as construction 78.

For the unchanged record spelling, actual encoded length remains

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

where e(b)=2|b|+2 and fixed phase delimiters contribute their actual symbols. No supplied decomposition or padding is added. All preparation, old-storage observations, allocations, pointer/name routing, comparisons, discarded speculative records, replay queues, current-version access and final output cost $O_d(N)$ logical work and storage. Explicit binary pointer serialization costs $O_d(N\log(N+2))$ bits.

All root tuples, pending builders, cursors and chunk labels have arity or size bounded by constants depending only on d. The established simultaneous-record compiler fixes degree, radius, finite labels/control and old-top semantics, with constant initialization and N+1 physical nodes. This is one fixed automaton for each fixed d, not one automaton accepting arbitrary input-supplied delay bounds. No identity, address, metadata, timing or control-flow side channel occurs. The PEG consequence concerns reversal of the entire checked language only.

7. What has changed, and what remains open

Construction 80 supplies the subsequent growing-delay release envelope, with a charged producer and an exact restricted scheduling criterion. The fixed-delay construction here remains a special case.

The suffix-only mechanism is already within the earlier bounded-prefix-ambiguity idea: after j bits, at most d output bits remain unknown, giving at most $2^d$ possible length-j output prefixes. The contribution here is its charged composition with an arbitrary learned first-half replacement, including producer construction and the replay deadline. It is not a new general transducer theorem.

The family $\alpha=\operatorname{rev}(a)$, $\beta=z$ is included and retains construction 78’s unbounded early-prefix ambiguity witness against the section-16 whole-word criterion. Learned nonidentity suffix maps extend construction 78’s unchanged-suffix contract. These comparisons do not separate the construction from every earlier sufficient theorem. In particular, a prefix trie is an unfolding of observed finite words, not a general input-built cyclic transducer with named states, shared joins or minimized behavior.

A proposed shortcut fails if it allows an unbounded final output burst: r output bits released only at the last symbol cannot be consumed at fixed rate for unbounded r. Whole-suffix reversal on the full domain also violates fixed-delay consistency. These facts reject the stated pipeline or contract, not native recognition or other precomputed representations.

The next test at this assessment was unbounded delay with enough actual residual service time. Construction 80 now supplies the stated envelope subclass; arbitrary suffix transformations remain open. Replace the fixed-lag condition by an input-built release rule that can be checked during ordinary right records, and prove the tail-service inequalities without supplied annotations or a final scan. Start with a suffix split into a learned delayed block followed by meaningful remaining bits, allowing a growing number of such releases only if their pending state and deadlines remain bounded locally. Arbitrary whole-suffix permutations, arbitrary-name routing and heterogeneous service remain open.

Replay slices still pay replay on each fork. Affine joins retain their coordinate contracts. Causal persistence preserves histories but does not supply current answers. Unary coherent algebra does not supply arbitrary branching composition. Native SAT controls retain ordinary late pins and negative final output. Entry 129’s relation quotient and matching/positive-path bounds keep their state/port scope; this construction uses branching, sharing and exact local negative readout and establishes no unrestricted lower bound.

Independent finite audit and review record distinguish bounded model experiments from the written native proof.