Grow support in separately owned components

12 October 2026. Written native construction 72, extending frozen-support construction 71. No root-ledger admission or external priority claim.

The current investigation guide places this result alongside its successors. The two-omission review identifies the current paid strict-extension target; it does not remove this note’s hypotheses or close its remaining frontier.

Result and payoff

Later support growth need not reinterpret previously completed rows. Keep old support coordinates fixed. When a new target appears, let its ordinary alias own a new component during its consecutive block of records. Within that component the owner contains every leaf and all other rows are empty. Freeze the component before another alias uses it. A fixed number of these independently prepared coordinate systems supports exact current union with a fixed number of readers.

Criterion. For fixed component capacity and a checked name-sized total mixed-region budget, birth-owner blocks permit persistent serial composition and late support growth at bounded work per actual symbol. The number of new leaves in a block, the number of rows, and unary path lengths are not bounded. The number of component births is bounded. This identifies a stronger readout than forcing all rows into one continually refined coordinate tree.

For two components, the construction handles a late support birth after arbitrarily many completed rows, followed by arbitrarily many new targets in its owner block and immediate short-alias selection. No previous row is converted to the new component’s coordinates.

1. Exact ordinary-input contract

Fix integers $K,C\ge1$. Use the same right-first Horn records (-01v,+1w);, left records (-00u,+01v);, and late pins (+00a);(-1q); as construction 71. All names are nonempty binary words and leading zeros count. Right targets have one common width $n>0$; right and left intermediate aliases have one common width $\ell>0$. Source names and pin lengths are unrestricted. The machine checks syntax and widths.

The following deterministic procedure derives the support components from the actual right records. No decomposition is supplied.

1. Initially no component exists. The first target starts component $U_1$ with its current alias as owner.
2. A component is active only during the consecutive run of its owner’s alias containing its birth record. A birth may occur partway through such a run. Before reading a target whose alias differs from the active owner, freeze that component.
3. If the target belongs to a frozen component, update the current row there. Do not add it to the active component.
4. Otherwise, if a component is active, insert the target into that component. The current alias is necessarily its owner.
5. Otherwise start the next component with this target and the current alias as owner. Reject the structural gate if this would exceed $K$ components.
6. Freeze any active component at the right/left boundary.

Thus components are nonempty and pairwise disjoint. Targets in an active component, including duplicates, follow rule 4. Duplicate targets in older components follow rule 3. An alias may own several components at different times. Old-component records can occur inside an active owner’s block; they do not end that block. After freezing, a component never gains another target.

For each right row $X_v$, define its total mixed budget using the final component supports:

$$m(v)=\sum_{j=1}^{k}M_{U_j}(X_v\cap U_j),\qquad k\le K.$$

Here $M$ counts mixed BRANCH occurrences in the aligned view on the support’s unary-suppressed literal trie, exactly as in construction 71. Require $m(v)\le C\ell$ for every final row. Intermediate violations may recover. A missing row is empty in every component. The structural gate is this specific birth procedure and budget, not an assertion that some suitable partition exists.

For an empty right factor, use construction 71’s empty-support branch, learning the common alias width from the first left record if one exists. The product is empty. Off-support or wrong-width pins yield false product membership and hence SAT, rather than structural rejection.

Theorem 72. For every fixed $K,C$, one deterministic native scaffolding automaton recognizes precisely the well-formed formulas satisfying these gates that are satisfiable. Degree, observation radius, labels, control and initialization are fixed for that automaton. It obeys immutable old-top updates and bounded work and allocation per actual input symbol, including final output.

With the same encoding,

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

plus the actual fixed phase delimiters. Logical work and retained records are $O_{K,C}(N)$. The inherited simultaneous-record compiler produces $N+1$ physical scaffold nodes; explicit pointer encodings use $O_{K,C}(N\log(N+2))$ bits. This is a family indexed by fixed constants, not a single automaton with growing $K$. Native recognition implies a PEG for the reversal of this complete checked language.

2. Why growth does not change other predicates or budgets

Reserve $K$ component slots in each row header from the start. Unused slots denote EMPTY. Creating a component changes its global support slot and its owner’s row slot to FULL. It does not visit other row headers.

While component $U_j$ is active, its owner is the only alias allowed to add targets to it. Each of its leaves was inserted by an actual record for that owner. Therefore the owner’s restriction to $U_j$ is FULL and every other row’s restriction is EMPTY. Both have mixed count zero, however the support grows. Records landing in an older component change only that older, frozen coordinate view. The first different alias freezes $U_j$ before its target can affect any row there.

Induction on right records proves pairwise disjointness, exact row denotations and the following stability invariant: support growth changes no unmodified row predicate and no mixed-budget contribution. The owner itself gains exactly the target authorized by its new ordinary record. Each historical store root retains its own support vector; historical FULL is interpreted with that vector, never with a later support. Retaining only a bare FULL flag without its enclosing support state is not the persistence contract.

This is the crucial difference from refining a common support beneath arbitrary completed FULL rows. New components introduce new coordinates in which those rows are uniformly empty. Only after freezing can nontrivial row patterns develop there.

3. Paid component discovery and row production

Use the charged dictionaries, coherent literal-trie insertion, strict path FIFOs, ready writeback capsules and fixed-batch compiler of the maintained producer, as instantiated in construction 71. No new random-access or pointer-identity operation is introduced.

During every alias, look up the current row header, check its common width, and construct a literal copy of the current alias. If a component is active, compare against its stored owner name while these bits arrive. At the alias endpoint, a mismatch freezes the active support by retaining its current pointer. The current alias copy is ready before the target starts, including when a component birth is discovered only at that target’s endpoint. A prospective unary capacity $C\ell$ is built in parallel with lookup and used if the row is new; this does not wait for an end-of-name absence result.

During every target, run a fixed batch of workers:

• The common-width ruler checks the actual target length.
• Each frozen support’s explicit literal trie validates membership and emits only its genuine branch events. Its row worker speculatively performs the inherited coherent insertion and mixed-budget calculation.
• If a component is active, a speculative coherent insertion extends its explicit literal support trie.
• A separate candidate builds the entire target as a singleton literal trie from its actual symbols, even before knowing whether a component birth is needed.

There are at most $K$ support workers. Each performs bounded work per actual bit. Keep support child-presence information explicit, including inside a full literal subtree, as in construction 71. Candidate and discarded speculative allocations count toward $O_{K,C}(N)$; they are not reclaimed or erased from the accounting.

At a valid target endpoint, disjointness means at most one frozen component matched. If one did, commit only that component’s completed row insertion and discard the speculative active-support insertion. If none did and a component is active, commit its support insertion and keep its owner’s component view FULL. If neither case applies, promote the already built singleton candidate into the next support slot and install FULL in the current owner’s corresponding row slot. Every case changes only a fixed header batch. There is no target replay, backward traversal, compressed-edge comparison or delimiter unwind.

Invalid targets commit no speculative mathematical update and set the structural rejecting flag. An exhausted component capacity also rejects. The outer dictionary capsule writes back the newly completed row header, not a delayed header captured before the target. Only the right phase grows supports; source composition begins after every support is frozen.

4. Exact total-budget maintenance

Retain one signed unary budget $B_v=C\ell-m(v)$ per row. Initialize each frozen component’s speculative budget calculation from this same current total, not from a separate full capacity.

For an insertion into component $j$, let $e$ be the old mixed coordinates on its branch path and $h$ the new mixed coordinates on that path, determined by the inherited last-nonfull cutoff. Construction 71 proves

$$M_{U_j}(X_v\cap U_j\cup\{w\})=M_{U_j}(X_v\cap U_j)-e+h.$$

All other component contributions are unchanged. Thus the new total budget is $B_v+e-h$. The streamed signed-register recurrence from construction 71 computes it using that component’s branch events; literal unary symbols still run validation. A duplicate preserves the old total. At the endpoint commit only the unique matching component’s speculative budget. Active-support insertion or component birth changes the owner’s new-coordinate contribution by zero and retains its previous total budget.

Maintain a global unary count of negative-budget rows. A completed record can change only its current row’s sign, by at most one contribution. At the right boundary a zero test checks every final row without scanning. The growth invariant proves that no other sign changes silently. Intermediate negative values remain permitted. All signs, zero tests, fixed-unit arithmetic and endpoint selectors have bounded local implementations under the inherited interfaces.

5. Composition, interrupted work and late answers

After the right phase, supports are fixed. A row is a vector of at most $K$ aligned views, with absent slots EMPTY. Boolean union is componentwise asymmetric splice. If $X$ is the incoming vector, its complete recursive call count satisfies

$$\operatorname{calls}(B,X)\le K+2\sum_jM_{U_j}(X_j)\le K+2C\ell\le(K+2C)\ell.$$

A call, return frame, observation and allocation have fixed cost. Multiplying by that cost gives a fixed service rate depending only on $K,C$. No bound on the accumulated baseline’s mixed count is needed. Union is exact componentwise, and the disjoint supports make its global denotation exact.

For each source retain committed vector $B_u$ and one pending vector $Q_u$. Its answer is their union. The ordinary source name opens the current header. The next actual intermediate alias supplies $\ell$ symbols of service to finish the previous vector splice, including returns and ready writeback, while row lookup proceeds in parallel. At the record delimiter install the finished baseline and the new row vector as the sole pending vector. Missing rows are EMPTY. Since aliases are nonempty, even the $K$ constant-root calls have an actual input payer. The incoming row does not disturb an older unfinished job: it is installed only after that job completes.

At the pins, the actual source name retrieves the two vectors. Run at most $K$ literal support validators and $2K$ aligned view readers in a fixed batch. A target bit emits at most one branch event per component. Each component’s contribution is its literal membership test AND the OR of its committed and pending view answers. OR the at most $K$ contributions and complement for pinned Horn SAT. Wrong-width and missing-support cases are false membership. The answer is ready at the final semicolon without completing a merge during the query.

Storage preparation, owner/name routing, old observations, candidate construction, temporary views, allocation and output are all charged above. There are no supplied handles, padding, advice, free preprocessing, hidden identity/address/metadata/timing channels, or EOF service. This supports serial reuse of one prepared right store; it does not join independently owned arbitrary stores in constant time.

6. One-branch refinement explains the avoided cost

For comparison, refine one support tree by replacing subtree $S$, at an old branch path $a$ of length $d$, with a binary node having children $S$ and one new leaf $z$. Let an old row $X$ exclude $z$. Its mixed-count increase is exactly

$$\Delta M=\#\{\text{strict ancestors of }S\text{ whose old view is FULL}\}+\mathbf1[X\cap S\ne\varnothing].$$

Every old mixed ancestor stays mixed; every empty ancestor stays empty; every full ancestor becomes mixed because the new leaf is absent. The inserted node is mixed precisely when the old subtree contributes a leaf. Other coordinates are unchanged. For $X=U$, this is $d+1$ even though the old mixed count is zero.

A single lazy adapter can still expose children in constant local work if the expanding record constructs the shared path cursor while its target arrives. An old EMPTY view stays EMPTY. Along the affected path, expose an old nonempty view as BRANCH; advance the cursor only on its affected child, retaining the old sibling. At the inserted node expose the old subtree and EMPTY. Off-path children require no adapter. This preserves old meanings without an eager row scan.

However, the inherited splice can perform $2d+3$ calls, hence $\Theta(d+1)$ work when its baseline is the new singleton and its incoming predicate is old FULL: both are mixed along the entire inserted path. Constant-cost child access alone therefore does not preserve a short-alias merge bound. This is a failure of that splice transfer, not a lower bound on all representations. The component construction instead keeps old FULL in the old support and represents the new support in another lane; its row view there is EMPTY. No coordinate adapter is required.

7. Scope, evidence and next target

For $K=1$ the checked language and producer recover construction 71. For $K=2$, an old support may already have arbitrarily many completed rows when a new owner block introduces an arbitrarily large disjoint support. Old rows stay empty in the second component; the owner may simultaneously have an arbitrary checked row in the first. Reusing an earlier alias as the new owner is allowed. Long common stems remain paid by literal target input and do not multiply selection work.

The restriction is genuine. Repeated new targets separated by owner changes can exhaust all $K$ slots. The construction does not bound such a growing family by a constant number of readers, and it does not claim that an arbitrary support refinement preserves the old mixed budget. Variable alias widths, nested ownership holes and independent-store joins remain separate frontiers.

Remove the fixed support-component cap while preserving paid current union and bounded active readers. Start with many component births under a long common literal prefix, arbitrary short aliases and an immediate negative pin. Account for each row’s FULL/EMPTY component activation pattern as well as its internal mixed regions; charge directory construction, activation and pending union to actual creating, selection or query symbols. Use the early unique-routing subclass as a control. Variable alias widths, nested ownership holes and independent-store joins remain separate. The early unique-routing subclass already supplies a positive control under its stated routing premises; those premises are not supplied by arbitrary support births. Internal mixed count alone does not count an unbounded vector of uniform component activations.

This is a written extension of the Lab’s frozen-support producer and asymmetric splice. Its additional mechanism is an input-derived bounded-width support partition whose growth is confined to a uniform owner coordinate. Independent review and the finite audit are recorded in assessment 216. Finite host sets, strings and counters are semantic oracles, not native instructions. No new primary review or external priority claim is counted.

Imported entry 129 retains its growing alphabet and state/port contracts. Replay pays each traversal, affine joins still need paid coordinate access, persistent causal sharing alone does not maintain union, and unary coherent algebra alone does not provide branching readout. Here the fixed component count, literal validators and stable mixed budgets together supply a charged positive criterion; no native lower bound follows.