Freeze the support, then compose in its branching coordinates

12 October 2026. Written native construction 71, independently reviewed with evidence recorded in assessment 214. No root-ledger admission or external priority claim.

Result and explanatory payoff

A long shared prefix need not be traversed again whenever a row is selected. Learn the target support from an actual first row, freeze it, and retain only its branching decisions as composition coordinates. Literal target input still validates every skipped symbol. The number of mixed branching regions in each incoming row pays union; the next ordinary alias pays that work; one directly readable pending row preserves immediate answers.

This gives a sufficient structural criterion: a paid, frozen common support plus a name-sized mixed-region budget permits persistent serial composition independently of unary path lengths and row degree. The first-row restriction supplies the stable support. It is a restriction on the relation and its input order, not an externally supplied decomposition. Construction 70 remains a separate result for dynamically learned contexts and bounded row degree; neither theorem contains the other in general.

1. Exact checked language

Fix an integer $C\ge1$. Use ordinary right-first Horn records (-01v,+1w);, then left records (-00u,+01v);, followed by pins (+00a);(-1q);. Names are nonempty binary strings; leading zeros count. Keep the inherited fixed phase syntax. If there are right records, let $v_*$ be their first alias, and let the anchor block be the maximal initial consecutive block whose alias is $v_*$. Its actual targets define a nonempty finite set $U$.

The machine checks these restrictions:

1. Every right target has one common positive width $n$, learned from the first target.
2. Every right and left intermediate alias has one common positive width $\ell=|v_*|$.
3. Every target after the anchor block belongs to its frozen support $U$. Later records for $v_*$ are permitted, but can only duplicate targets already in $U$.
4. Every final right row $X_v\subseteq U$ has $M_U(X_v)\le C\ell$, where $M_U$ is defined below. Intermediate violations may recover.

The anchor row is an ordinary row of the relation, with $X_{v_*}=U$; selecting it makes all supported targets reachable. It is not ignored padding, an auxiliary oracle or a succinct description. Other rows may interleave and contain duplicates. Source names and both late pins have unrestricted positive lengths. Neither $n/\ell$ nor $\ell/n$ is bounded.

If the right block is empty, there is no support and the product is empty. In that case learn a common positive alias width from the first left record, if any; check it on subsequent left records. With both factors empty there is no width to establish. These branches accept exactly the well-formed SAT instances passing their stated width gates.

Theorem 71. For each fixed $C$, one deterministic native scaffolding automaton recognizes exactly the well-formed formulas satisfying these checks that are satisfiable. It has fixed degree, radius, finite labels/control and initialization, obeys immutable old-top updates, and uses bounded work and allocation per actual input symbol, including final output.

The encoded length is

$$N=\sum_R(9+|v|+|w|)+\sum_L(10+|u|+|v|)+11+|a|+|q|,$$

plus actual fixed phase delimiters. The construction uses $O_C(N)$ logical work and records, and the inherited simultaneous-record compiler gives $N+1$ physical scaffold nodes; explicit pointer encodings cost $O_C(N\log(N+2))$ bits. No supplied handles, advice, preprocessing, inserted service symbols or EOF work are allowed. The native-to-PEG consequence concerns the reversal of this complete checked language.

2. The shared coordinate tree and its negative observation

Take the ordinary literal trie of $U$ and suppress each unary path. The resulting ordered full binary tree $T_U$ has leaves $U$ and need not have equal leaf depths. Its internal nodes are precisely literal prefixes with two nonempty support children. A leaf’s code records its left/right choices at these nodes. These codes are prefix-free, including the empty code when $U$ is a singleton. Creation order never changes these coordinates.

At a node $t$ let $U_t$ be its descendant support leaves. An aligned view of $X\subseteq U$ is EMPTY when $X\cap U_t$ is empty, FULL when it equals $U_t$, and otherwise BRANCH with views at the two children of $t$. Only uniform nodes may collapse. A row must not independently suppress a nonconstant branching level: all nonconstant views follow the same $T_U$ decomposition.

Define $M_U(X)$ as the number of BRANCH coordinate occurrences in this unfolded view. This counts coordinates even if physical records are shared. For the literal mixed-prefix count $P_n$, we have

$$M_U(X)\le P_n(X),$$

because each mixed support branch is a distinct mixed literal prefix. The inequality can remove an arbitrarily long unary stem. It is not an information-size lower bound.

Literal validation is essential. During a query, traverse the frozen ordinary support trie one edge per actual target bit. At a node with two nonempty support children, emit that bit to each aligned view reader; at a unary node emit nothing. A missing edge makes membership false. Require a support terminal at the literal endpoint. Thus FULL means all supported descendants, not all literal extensions. For example, with $U=\{000,111\}$ and $X=\{000\}$, reduced routing of 001 reaches FULL after its first bit, but literal validation correctly makes membership false. Wrong-width and off-support pins yield false product membership and hence SAT; they are not malformed-input rejection.

The implementation need not construct a separate compressed global tree or compare compressed edge labels. The ordinary frozen trie supplies branch events with constant local child-presence observations. There is at most one event per actual bit. Interior and terminal flags, null edges and positive/negative presence observations have finite labels; no address, identity, metadata or timing side channel is used.

3. Paid discovery and the support-freezing gate

During the anchor block, build $U$ with the inherited coherent ordinary-name trie insertion, retaining an explicit logical node view at each literal position. Keep its child structure even at full literal subtrees; the support decoder needs local child-presence views, not an opaque FULL shortcut. The first target builds its unary width ruler; later targets traverse a copy of that ruler to check equality while their bits arrive. Build and retain the first alias’s literal name/ruler during its own input. Every subsequent alias compares against that name and checks its width as it is read. At the first unequal alias, freeze the completed current support root by copying one pointer. All anchor target work has already finished before this alias ends.

No scan, balancing, compressed-edge construction or row recoding occurs at freezing. Until this point the only row is the anchor itself, whose final support-relative view is FULL and mixed count is zero. If there is no unequal alias, freeze at the right/left phase boundary with the same constant work. After freezing, every actual target is checked by the literal support reader before its row update is committed. A later anchor occurrence keeps its FULL view and only validates membership. An outside-support target sets a rejecting structural flag; it never expands $U$.

Ordinary dictionaries, strict persistent path FIFOs and ready path capsules are the already charged primitives of the maintained native producer. Source/row lookup is performed while its actual name arrives. The outer row capsule is retained across its target and writes back the newly completed header, not a stale delayed version. We add no pointer-addressing or random-access operation.

4. Streamed row views on an unequal-depth skeleton

For a non-anchor row, its alias opens the current row header. On its first occurrence, $C$ fixed unary units per alias bit prepare capacity $C\ell$. During its target $w$, run the literal support reader. Feed only emitted branch bits into the coherent row insertion. On each event read the old chosen child and untouched sibling in the aligned view; constants have virtual constant children. Append the chosen bit and old sibling to the strict path FIFO. Increment a unary branch-depth ruler and capture it at every nonfull sibling. No work is required from future target symbols.

At a valid endpoint, the chosen support coordinate is a leaf. The new leaf is present. Publish the path FIFO, last-nonfull cutoff and present leaf as a fixed-field capsule. Its selected child removes one frame and one cutoff unit; its other child is the captured old sibling. New fullness is exactly the test that the cutoff has emptied. Old flags are interpreted before capture, so a view does not recursively interpret a stack of old capsules. All temporary view allocations count.

This is the fullness-cutoff construction from section 32.3 with depth measured in branch events, not literal positions. Its proof uses the conjunction of untouched-sibling fullness along a finite root-to-leaf path. It never requires equal subtree heights. There is no return walk at a delimiter, even when branch events are separated by long unary paths or the final event is on the final target bit. A singleton support emits no events: an insertion changes EMPTY directly to FULL. Duplicate membership is observed at the old leaf and retains the old row.

For completeness, the mixed-budget update also survives unchanged. On a genuinely new leaf, let $e$ count old mixed nodes on its reduced path and let $k$ be the depth immediately below the last nonfull untouched sibling, or zero if none. Off-path mixed nodes are unchanged, and exactly the first $k$ new path nodes are mixed. Hence

$$M_U(X\cup\{w\})=M_U(X)-e+k.$$

Let $B=C\ell-M_U(X)$. Start signed unary registers $A=V=B$. At each emitted branch bit, let $m$ indicate that the old current row view is mixed, and let $f$ be the untouched sibling’s fullness. Update

$$A\gets A+m-1,\qquad V\gets\begin{cases}A&f=0,\\V+m&f=1.\end{cases}$$

The reset uses the updated $A$. After $i$ events, $A=B+e_i-i$ and $V=B+e_i-k_i$. Therefore the endpoint’s $V$ is the exact new budget. Each register uses a finite sign and unary magnitude; fixed unit changes and zero/sign observations have bounded local cost. A duplicate keeps the old budget. An absent row starts with its already paid capacity; an empty reduced path has $e=k=0$.

Maintain a current global unary count of negative-budget rows. Each completed record changes it only when that row’s sign crosses zero, by at most one. At the right boundary its zero test checks every final budget without scanning rows. Intermediate negative values are allowed. Invalid targets do not commit speculative updates. All target-width checks, membership, row construction, counters and the outer dictionary capsule run in a fixed parallel batch per actual symbol.

5. Union, old pending work and exact future answers

For aligned views use the existing asymmetric operation $\operatorname{Splice}(B,X)$: EMPTY incoming returns $B$; FULL incoming or FULL baseline returns FULL; EMPTY baseline returns $X$; otherwise recursively splice corresponding children and collapse two FULL children. A recursion occurs only at a mixed coordinate of $X$. Thus

$$\text{calls}\le1+2M_U(X)\le1+2C\ell.$$

Each call and return uses a bounded frame, fixed local observations and bounded allocation. This counts all work, not just descent or new physical nodes. The bound is independent of the size or history of $B$. Induction on the finite support subtree proves exact Boolean union, without a height counter.

For each source $u$ retain committed $B_u$ and one pending $Q_u$ with

$$\operatorname{Ans}(u)=\operatorname{set}(B_u)\cup\operatorname{set}(Q_u).$$

The actual source name opens its current header before the intermediate alias begins. During the next $\ell$ actual alias bits, a fixed service rate depending only on $C$ completes the previous $\operatorname{Splice}(B_u,Q_u)$, including return frames and ready commit. In parallel the alias looks up its frozen right row. At the record delimiter install the completed baseline and the newly found row as the only pending root. Absent rows are EMPTY. The outer writeback uses the already paid source capsule; there is no delimiter unwind. Duplicates are idempotent.

This discharges the old-job disturbance question in this subclass: the new row is not installed until the old job is finished. There are never multiple suspended splices whose residual work a new insertion can increase. At any truncated point of the service interval, remaining work is at most the original fixed $O_C(\ell)$ job bound. No banked right-phase time or future EOF service is used.

At the pins, the actual source name obtains the two roots. Every target bit advances literal validation and, if it emits a branch event, both aligned readers. FULL/EMPTY readers stay constant. After the literal endpoint, validation and the two terminal truth values give exact current product membership, and its complement is the pinned Horn SAT answer by the final semicolon. No splice is required during the query. This remains true when $n$ is far shorter or longer than $\ell$. Retained roots and capsules preserve each previous version; serial reuse of the prepared right store is supported, not an independently owned constant-time join.

6. The two stress families and the remaining boundary

Many short selections below a long stem. Put $L=2^d$, $U=0^L\{0,1\}^{d+1}$ and use $\ell=d+1$ bit aliases. Give the anchor alias $0^{d+1}$ its entire literal row $U$. For each $c\in\{0,1\}^d$, give distinct alias $1c$ the sibling pair $0^Lc0,0^Lc1$. Its reduced mixed count is $d\le\ell$, independent of $L$. A source can select all these rows in arbitrary order. Each pending merge costs $O(d)$, not $O(L)$; the query validates the long stem once. All exponentially many literal anchor targets remain in $N$, and the anchor is a genuine selectable relation row. This is a checked positive version of the common-stem stress test, with an explicit support-first premise.

A cone across arbitrarily many contexts. Give one-bit anchor alias 0 every word of length $D+2$, in any order. Alias 1 has every such word beginning in 0. The support is the full cube and the second row has $M_U=1$, regardless of degree or context creation order. Both rows pass $C=1,\ell=1$ for every $D$. Thus the creation-order fragmentation witness is handled in literal branching coordinates, with no exponentially large code geometry. This does not remove construction 70’s degree hypothesis; it is a different native subclass.

Why unrestricted support growth is still open. If $X=U=\{00\}$, its support-relative root is FULL. After another row adds 01, the old $X$ must mean BRANCH(FULL,EMPTY) in the new support. Keeping the old FULL meaning would change its answer. Replaying all previous rows at freezing can also be unpaid: many short names may refer to long paths after their last target input has already passed. A semantic quotient, a static handle or a compact final trie does not pay this migration. Versioned support views or a checked later witness schedule remain possible; this example is not a general impossibility theorem.

The next decisive target is to allow a later support expansion while preserving previously built row predicates, their mixed budgets and constant local child views. Begin with one added support branch after many completed rows and an immediate short-alias selection; charge any old-view conversion to the expanding record or a proved later ordinary-input witness. A construction must retain the literal validation gate and current source semantics. Variable alias service widths, arbitrary nested context holes, clipped depth intervals and independent-store joins remain separate.

Contribution, evidence and controls

This is a written adaptation and extension of the Lab’s coherent cutoff producer and mixed-region splice, using frozen support-relative coordinates to separate preparation, selection and literal validation. The closest mechanisms are sections 32.3 through 32.7 and constructions 69/70; no claim of external priority is made. It is a subclass theorem, not a new admission in the root ledger.

The independent finite audit checks nonuniform support trees, branch streaming, signed-budget identities, old versions, support freezing, rejection gates, merges and immediate pinned answers. Finite host computations are semantic and operation-count oracles, not an execution of the compiled native automaton. The universal timing proof is the bounded-batch construction above.

Imported entry 129 retains its growing alphabet and state/port contracts; no native lower bound follows. Replay still pays traversal, affine joins do not supply coordinates, causal persistence alone does not maintain a current union, and unary coherent algebra alone does not supply branching composition. Here the first row supplies and pays the stable shared coordinate support; negative local presence/fullness observations and the separate literal validator supply exact readout.