Release envelopes for persistent composition

13 October 2026. Written construction 80 and an exact criterion for a restricted output pipeline. A sufficient native subclass, with no root admission or external priority claim.

1. Result and payoff

Independently prepared namespaces can share one current activation dictionary even when a suffix program delays its first output by a growing fraction of the query. The structural condition is how much output each input prefix determines relative to the remaining service time. A prescribed envelope replaces discovery of a release schedule from the completed table.

Sections 1–7 establish the one-path case. Section 8 extends the charged construction to a fixed number of speculative paths, including elimination on the last input bit.

Fix an integer $C\ge1$, a machine parameter. For suffix width $r\ge1$ define

$$e_C(j)=\max(0,r-C(r-j)),\qquad 0\le j\le r.$$

For each learned map key, require any two recorded suffix pairs $(z,\beta),(z',\beta')$ sharing their first $j$ input bits to share their first $e_C(j)$ output bits. Both words have length r. This includes functionality at j=r, allows sparse and noninjective maps, and imposes no output at j=0. Each increment of e is at most C; e(r)=r.

Envelope criterion. For a fixed finite table, this condition is equivalent to the existence of a non-speculative common-prefix output strategy whose ordered beta-bit jobs can be serviced at C jobs per suffix symbol and finish every supported query at its last symbol. This is a semantic scheduling equivalence, not a bound on every representation. A strategy may release only an output prefix shared by all recorded extensions of the target prefix; it may not guess a branch, pre-traverse several activation paths, or replace beta traversal with a prepared predicate. Preparation and output-discovery costs are deliberately separate from this equivalence.

Construction 80. With the ordinary encoding and right-first phase discipline below, the envelope condition itself is built and checked during actual records. One fixed native automaton for each C recognizes the checked satisfiable language, using the current activation dictionary once per source and bounded work on every actual symbol, including the final symbol. Growing delay does not require supplied release annotations, a post-table compilation pass, or EOF work.

2. Proof of the scheduling criterion

For a supported prefix p of length j, let g(p) be the length of the longest common prefix of the output words of all recorded extensions. This quantity is used only in the proof; the native producer will not compute longest common prefixes.

Suppose g(p)=k<e_C(j). After reading p, a non-speculative strategy can have released at most k beta jobs. On each supported continuation, at least r-k jobs remain unreleased until symbol j+1 or later. Only r-j service symbols remain, and

$$r-k>C(r-j).$$

No C-rate worker can finish. This proves necessity even if all previously released work has already been performed. A singleton continuation has g(p)=r and causes no false obstruction. This argument concerns the stipulated output discipline; shared predicates or speculative parallel paths are outside it.

Conversely, release exactly the next $e_C(j)-e_C(j-1)$ bits on symbol j, before that symbol’s service. Prefix consistency makes this release well-defined. Output bit i is released at

$$\rho_i=\left\lceil\frac{(C-1)r+i}{C}\right\rceil.$$

Equivalently, $r-\rho_i=\lfloor(r-i)/C\rfloor$. Therefore

$$r-i+1\le C(r-\rho_i+1).$$

Every ordered beta tail fits its remaining service slots. The ordered release-tail criterion proves completion. Indeed each chunk is already at most C, so a beta-only worker can consume it on its release symbol. This completes the equivalence without charging the construction of an arbitrary semantic table.

3. Ordinary relation records and representation

Use exactly the encoding, phase checks and once-only contiguous store groups of construction 78, and the nested program representation of construction 79. Here is the complete additional contract.

Right records are $(-01E(b)0,+1q)$; left records are $(-00u,+01E(b)v)$; pins are $(+00s);(-1t)$. E encodes each bit e as 0e and ends in 11. Record punctuation and phase delimiters are actual input. The nonempty right phase learns a common odd store width $m=2r+1$, r>=1, from the first actual store. Every target has $q=E(c)az$, with c of width m starting in 0, and a,z each of width r. A primary store is b=c. A foreign store is $b=1\alpha\beta$, with alpha,beta of width r. At each (c,a), all foreign records agree on alpha and the suffix table obeys section 1. The inherited checks reject other shapes and invalid group order; all left stores must be known right stores. Query pins remain ordinary names, with exact support deciding off-shape targets as in construction 79.

The static dictionary D(c)(a) contains an alpha stream and a suffix trie Q. Its node at depth j stores the chunk of beta in positions e_C(j-1)+1 through e_C(j), with a separate occupancy flag. Empty and missing are different. Terminal flags and the actual primary/foreign support predicates P,F retain recorded incidences. All chunks have at most C bits, so finite labels suffice for fixed C.

With the captured current activation dictionary B_u, the invariant is unchanged:

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

No inverse table or namespace-specific copy of B_u is updated on activation. Support prevents a partial learned map from inventing relation entries. Right records build static programs; left records update only their source’s activation dictionary. Retained versions remain immutable.

4. A charged producer without longest-common-prefix discovery

Construction 79 already prepares the actual alpha and beta streams, learns the full/half rulers, opens outer c and inner a capsule paths, and compares alpha during z. Preserve those operations and suspended paths. Replace only its finite-delay counter by the following stream of identical tokens.

During the r alpha-transfer steps while reading the actual E(c) field, prepend C-1 unary tokens per step to a counter chain. Thus exactly (C-1)r tokens exist before a and z. Each fixed-C batch allocates a bounded number of records. The chain contains no packed integer; its root and each tail are ordinary bounded-degree pointers. No unbounded copying of a ruler is performed. At C=1 the chain is empty.

On each actual z bit, perform C microsteps. A microstep removes one token if any remain; otherwise it pops the next beta bit into the current finite chunk. After j suffix symbols the number of beta bits popped is exactly e_C(j). For a well-shaped record beta is exhausted exactly at j=r, never earlier. Detect depth r with the inherited half ruler; overlong and short records fail the inherited shape checks. The C microsteps are a fixed batch in the native compiler.

At each reached Q node, compare the candidate chunk with an occupied old chunk, or install it if missing. Update its payload before descending, as required by the serial-capsule primitive. Preserve children, then set terminal support at depth r. At the actual delimiter check ruler and stream exhaustion and alpha equality. Close Q and the suspended inner and outer capsules in bounded work, and commit support and program together. The retained paths may have unbounded depth; closure cost, not depth, is bounded. A conflict abandons speculative immutable records and rejects.

Two rows agree on every shared chunk exactly when they meet the envelope prefix condition. Hence this online producer validates against all previous rows, independent of their order or store group, without comparing an unbounded output prefix at every trie node. The possible quadratic cost of separately rescanning longest common prefixes is avoided rather than assumed amortized. No post-table scan revises release times. This is why the semantic criterion has a charged realization here.

5. Query pipeline and strict deadline

During the positive source pin capture the current B_s. During E(c), read D(c) and the primary activation B_s(c). During a, reach D(c)(a), making alpha and Q ready. These are exactly construction 79’s paid routing operations. Initialize the foreign activation cursor at child 1 in a fixed batch.

On each z symbol, advance Q and enqueue its finite chunk before servicing the worker. The worker traverses alpha, performs the fixed setup/switch work normalized as two jobs, and then traverses beta in order. Set

$$K=\max(C,4).$$

Service K normalized jobs per actual suffix symbol. Each job has bounded primitive cost; the FIFO, program lane, support lane and ruler each have their own constant local batch. A missing activation path is an absorbing false cursor. Missing program/support paths can disable a lane; they never require a final search.

A tail beginning among the initial alpha/setup jobs has at most $2r+2\le4r\le Kr$ jobs and all r service symbols. A beta tail beginning at i has at most $C(r-\rho_i+1)\le K(r-\rho_i+1)$ jobs. All release tails fit, so alpha, setup and beta finish by the last actual z bit, despite their serial interference. This includes r=1 and C>r, when the whole beta is a bounded final chunk. At ordinary punctuation, actual support and the ready primary/foreign marks determine M_s(t). The final output is its Boolean complement, exactly the two-layer Horn SAT wrapper’s answer. Unsupported underlength or overlength query targets have false exact support, so their unfinished workers may be abandoned. No EOF flush is used.

The exact necessity in section 2 is for a beta-only C-rate pipeline. For C<4 it is not claimed necessary for the full K-rate alpha/beta pipeline, which may have spare capacity. The construction is sufficient at K and the semantic equivalence remains exact at C.

6. Native resources and scope

The literal encoded length is unchanged:

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

where e(b)=2|b|+2, with actual phase delimiters added. The envelope e_C and the encoding-length function e(b) are distinct. All initialization is constant. Preparation, token-chain allocation, old-storage observations, validation, discarded provisional records, queue operations, name and pointer routing, replay, retained storage and output take $O_C(N)$ logical work/storage. Explicit pointer serialization costs $O_C(N\log(N+2))$ bits.

Fixed C bounds chunk labels, batches, cursor/root arity and simultaneous capsule depth. The same simultaneous-record compiler used in constructions 78–79 fixes degree, radius, finite control/labels and old-top update semantics and allocates N+1 physical scaffold nodes. The $O_C(N)$ logical records are packed into fixed-size per-symbol batches. Input is processed in the stated right-first order, with output ready on the final actual symbol. One machine is fixed for each C; arbitrary input-supplied C is not admitted. There is no advice, supplied decomposition, padding, free endpoint handle, free preprocessing, or identity/address/metadata/timing/control-flow channel. Native recognition gives a PEG for reversal of this entire checked language, not automatically its original orientation.

7. Comparisons, failures and next test

The union over fixed C includes every construction-79 fixed-delay contract. For fixed d choose C=d+1. For j<r, writing L=r-j>=1 gives $e_C(j)=\max(0,j-dL)\le\max(0,j-d)$; the final output length is r in both contracts. The ordinary producer checks the weaker envelope directly.

The inclusion is strict for suffix contracts across unbounded widths. For r=2n, map z=xy to beta=rev(x)y, where x,y have length n and the domain is all binary words of length 2n. This satisfies C=2: up to j=n the envelope is zero; beyond n, the required output length 2(j-n) is determined, since rev(x) is known and any requested bits of y have already arrived. But at j=n-1, two extensions differing in the last x bit have distinct first output bits. No fixed d can force the required output bit there once n-1>d. For the separate bounded-prefix-ambiguity comparison, take $j=\lfloor n/2\rfloor$. The first j output bits are the last j bits of x, disjoint from the fixed first j input bits. There are $2^j$ possible output prefixes of length j, exceeding every fixed ambiguity parameter as n grows. This is a separation from those contracts, not from all native constructions or all prior sufficient classes.

Full-domain whole-suffix reversal fails every fixed C for sufficiently large r: at j=r-1 its common output prefix has length zero, whereas e_C(j)=r-C>0 when r>C. The restricted pipeline therefore fails. Other persistent representations, precomputed aggregate predicates or speculative bounded branching are not excluded. Entry 129’s imported matching and positive-path bounds retain their state/port hypotheses and growing alphabet; no unrestricted native lower bound follows.

Replay slices still pay replay on forks; affine joins retain their coordinate hypotheses; persistent causal and unary coherent algebra do not provide the growing current-activation reader automatically. This construction adds a producer-checkable dependency criterion: enough forced ordered output before each remaining-time boundary, with fixed-rate chunks and one captured activation version.

8. Bounded speculative width, built from ordinary records

The one-path criterion can be extended within the same run. Fix another machine parameter $W\ge1$. Replace the suffix condition in section 3 by:

• at every supported input prefix p of length j, there are at most W distinct recorded beta prefixes of length e_C(j);
• each complete suffix z has exactly one beta among its recorded foreign incidences.

Alpha remains unique at each (c,a); actual support and every other encoding/phase condition remain unchanged. This is an envelope-width condition, not a bound on the number of full suffixes or program nodes. It allows unbounded ordinary prefix ambiguity when e_C(j)<j. At W=1 it is exactly the earlier condition.

Construction 80, bounded-width form. For each fixed pair C,W, the resulting checked satisfiable language has one native recognizer with the same strict per-symbol and final-symbol deadlines, $O_{C,W}(N)$ logical work/storage, $O_{C,W}(N\log(N+2))$ explicit pointer bits, constant initialization and N+1 physical scaffold nodes under the inherited fixed-batch compiler. Each source still retains one current activation dictionary. This is a sufficient theorem; necessity for arbitrary speculative readers is not claimed.

Producer: finite local slots replace output-prefix comparison

At Q’s root there is one conceptual slot for the empty beta prefix. Every depth-j node stores an append-only array of at most W slots. A slot is the finite pair (parent slot index, next chunk). Indices range over a fixed W-element alphabet and chunks have length e_C(j)-e_C(j-1)<=C. All slots are literal finite payload data, not pointer identities or addresses.

When a foreign row arrives, the token producer supplies its chunk at each actual z symbol. Carry its selected parent slot index from the previous node. Look for the pair (parent index,chunk) in the current node’s array; reuse its slot if found, otherwise append it or reject if already full. Update this payload before descending. Carry the selected current index forward. At a terminal node reject an array with more than one slot, even if W>1. Alpha comparison, exhaustion/shape checks, support commitment and suspended capsule closure are unchanged.

Inductively, a parent slot denotes exactly one distinct beta prefix of length e_C(j-1). Appending its chunk denotes one prefix of length e_C(j). Different parent prefixes cannot become equal by extension; for one parent, different chunks remain different. Thus pair equality is exactly output-prefix equality and the array size is exactly the required width. Root empty chunks cause no exception. The induction proves acceptance precisely for the stated finite-table contract.

Slots never move or change meaning. A later insertion may append a parent slot, but every existing child reference retains its old finite index. No child rewrite, output-prefix scan, canonicalization pass or mutable backpatch is required. Only the row’s actual trie path is visited. The producer performs at most W finite comparisons per node and C token microsteps, all bounded for the fixed machine. This addresses construction and validation of the speculative program; the program is not supplied as input advice.

Readout: fork immutable workers and eliminate unsupported paths

Keep one worker tuple per slot in the current Q node. A tuple contains the current activation cursor, remaining alpha cursor, setup phase and pending beta FIFO root. Initially the single root tuple is construction 80’s one-path worker, before suffix service.

At the next actual suffix bit, read the selected child Q node’s finite slot array. For every child slot (parent index,chunk), copy the referenced parent tuple by its bounded root pointers, append that chunk to its persistent FIFO, then perform K=max(C,4) normalized worker jobs. There are at most W children, so this uses a fixed W*K service batch plus bounded cloning, slot and enqueue work. Several children may fork one parent; their FIFOs and cursors evolve immutably. Drop parent tuples not referenced by this child. No parent may disappear early merely because another candidate is currently promising. Missing Q paths disable the foreign term through exact support.

For any candidate surviving to the endpoint, trace its unique slot ancestry. Along this ancestry the queue receives precisely the envelope chunks and its worker receives K service opportunities on every suffix symbol. Forking copies already completed state and the same pending queue; it does not restart work or borrow future amortized credit. Induction on symbols reduces its completion bound to section 5’s ordered release-tail proof. There are only W current candidates, and every one receives the promised service. This charges all speculative work, including branches eventually discarded.

At a supported complete target, functionality leaves exactly one terminal slot. Its current-version activation mark is ready by the last suffix bit. Late input may discard every other candidate on that very symbol without scanning old storage. Combine this mark with actual foreign support and the primary term, then take the same local Boolean complement for SAT. Persistence of stored histories and exact negative observations are both used; no communication or identity side channel is introduced.

A precise stronger readout operation

For r>=2 on the full binary domain, let beta’s first bit be the XOR of z’s first and last bits, and leave all remaining bits unchanged. At C=1, any proper nonempty input prefix of length j determines at most two beta prefixes of length j. The full input determines one, so W=2 suffices. Both speculative activation paths are traversed, and the last input bit selects the surviving answer.

This family fails the W=1 contract for every fixed C as r grows: at j=r-1 the first output bit remains undetermined, but e_C(j)=r-C>0 for r>C. Thus bounded speculation is a genuine stronger operation than waiting for a single forced output prefix. The suffix example alone is already a fixed-prefix-ambiguity case of the earlier section-16 control. The additional content here is its input-built finite-slot implementation composed with the growing-delay envelope and arbitrary learned alpha map, not rediscovery of bounded branching by itself. Full suffix reversal still has unbounded envelope width: take r=(C+1)n and j=Cn, so e_C(j)=n while the last n input bits remain unknown. Its $2^n$ possible output prefixes exceed any fixed W. No unrestricted representation lower bound is inferred.

9. Next decisive test

Replace fixed simultaneous width by an input-derived speculative frontier whose actual branches receive paid service. A total-work inequality alone is insufficient: charge discovery, traversal and elimination when they become available, and account for stored but temporarily unserved candidate states. Determine whether a useful variable-width subclass admits such a local scheduler without scanning the frontier or receiving a supplied decomposition. Arbitrary whole-suffix permutations, arbitrary-name routing, cyclic state sharing and heterogeneous service remain open. The next editorial pass should preserve this mathematical target.

Independent executable evidence and adversarial review separate finite experiments from the all-length written proof.