Growing support inside an input-learned envelope

12 October 2026. Written native construction 73, using the Lab’s established coherent trie, signed-budget and pending-union primitives. No new root 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

Observed support can keep growing without changing old row meanings. Fix a larger coordinate universe early, and let a new target fill an existing empty coordinate. The first two distinct ordinary target names determine a common prefix; their remaining suffixes determine a fixed binary cube. A checked mixed-region budget on that cube pays later unions. The shared prefix is checked during input and queries but never traversed by union.

This answers the singleton-birth test from the component-directory investigation for an explicit stronger budget. There is no bound on later target births, no owner-block restriction, and no bound on the ratio between target and alias lengths. The price is that absent suffix names count in the budget. It does not make the observed-support combined budget natively checkable in general.

1. Exact checked language

Fix an integer $C\ge1$. Use the established right-first ordinary Horn syntax: right records (-01v,+1w);, left records (-00u,+01v);, followed by the two ordinary pins (+00a);(-1q); and the inherited fixed phase delimiters. Require at least two right records, with distinct targets $w_0,w_1$ in the first two records. This is a syntactic subclass; inputs with fewer records or equal first targets fail this gate. Neither record is auxiliary input: both are actual relation edges.

All right targets have one positive width $n$. Every intermediate name in either factor has one positive width $\ell$. Learn these widths from the first record; no relation between them is required. Let

$$P=\operatorname{lcp}(w_0,w_1),\qquad d=n-|P|\ge1,\qquad E=P\{0,1\}^d.$$

Every subsequent right target must belong to $E$. Source names and both pins have arbitrary positive lengths. Duplicates and arbitrary later alias interleaving are permitted. For each right row put

$$Y_v=\{z\in\{0,1\}^d:Pz\in X_v\}.$$

Let $A_d(Y)$ count internal suffix-cube prefixes whose descendant leaves meet both $Y$ and its complement in the entire cube. Check only the final condition

$$A_d(Y_v)\le C\ell.$$

Intermediate violations can recover. The first alias has no privileged semantic edges after bootstrap; it remains an ordinary row and can receive any later targets passing the same gates.

Theorem 73. For each fixed $C$, one deterministic native scaffolding automaton recognizes precisely the well-formed formulas satisfying these gates that are satisfiable. Degree, radius, labels, control, initialization, per-symbol work and allocation are fixed independently of $n,d,\ell$, row count and support size. Updates use only the old top and immutable retained records. Output is ready on the final symbol. Its language reversal has a PEG; no forward-language closure transfer is asserted.

The actual length is

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

plus actual fixed phase delimiters. All preparation, literal routing, old-storage observations, deferred work and output use $O_C(N)$ logical work and retained records. The inherited fixed-batch compiler gives $N+1$ physical scaffold nodes; explicit pointer serialization costs $O_C(N\log(N+2))$ bits. There is no supplied decomposition, ready handle, padding, advice, external preprocessing or EOF flush.

2. Coordinates are fixed before other rows accumulate

The full depth-$d$ suffix cube is implicit. It is never enumerated. EMPTY and FULL have virtual constant children; a mixed view is BRANCH with two aligned child views. FULL refers to all suffixes of the remaining width, including names not yet observed globally. It can be produced only after actual insertions fill that entire cylinder. In particular a singleton is not FULL above its depth-$d$ leaf merely because it is the only observed target there.

Unlike a growing support trie, adding an ordinary target changes no coordinate, no old row view and no other row’s budget. This is the structural reason that no repair scan is needed. It substitutes a stable larger domain for the moving observed-support domain.

The literal width and prefix reader is separate from the Boolean view. A query first checks $P$ bit by bit, then supplies exactly its suffix bits to the two view readers, and checks the target endpoint at width $n$. A wrong-prefix, too-short or too-long pin gives false product membership and hence SAT, provided the formula syntax and structural right/left gates are valid. It is not a malformed-pin rejection. A FULL suffix view cannot bypass literal validation.

3. Paid two-record bootstrap

The following uses the strict persistent forward FIFO, coherent path capsules and bounded simultaneous-record compiler already established in the maintained native producer. Each FIFO enqueue, head and tail operation has the inherited worst-case bounded local contract; a reversed list with unpaid reversal would not suffice.

During the first alias, retain its literal name, width ruler and a capacity counter of $C\ell$ unary units, constructed at $C$ units per actual alias bit. Keep this first alias as one distinguished explicit row outside the ordinary row dictionary for the entire input. Every later alias compares against its saved spelling in parallel with dictionary lookup. At its endpoint, the equality flag selects the distinguished row or the dictionary result. Thus there is only one dictionary write per later ordinary row update. No stale saved first-alias path is written over a second-alias insertion.

During the first target, append its bits to a strict forward FIFO and construct the width ruler $n$. During the second target, traverse an independent cursor through this FIFO in lockstep. Before the first disagreement, construct a unary prefix-length ruler one unit per matched bit. At the disagreement, freeze that ruler and retain the two current bits. From this bit onward, construct a suffix-width ruler one unit per actual bit. The remaining cursor supplies $w_0$’s suffix while input supplies $w_1$’s suffix. The comparison and both suffix builders run in a fixed parallel batch. No subtraction of long rulers or return walk occurs at the endpoint. Equal targets, unequal widths and bad syntax are rejected by flags.

Retain the complete first-target FIFO as the later prefix comparator. Its head and the frozen prefix ruler identify the prefix without copying or extracting it at the delimiter. A fresh cursor stops comparing precisely when the ruler empties. The empty prefix is allowed.

There are only two initial rows to construct. If the aliases differ, build one suffix singleton capsule for each stream. Each has mixed count $d$ and budget $C\ell-d$, maintained by one decrement per suffix bit. The first goes into its distinguished slot; the second uses its ordinary dictionary capsule captured during its alias.

If the aliases agree, the two suffixes differ at their first bit. Build their two tail singleton capsules in parallel. At the endpoint, either $d=1$, in which case their union is FULL with mixed count zero, or $d>1$, in which case a new root joins the two nonempty proper tail views, with mixed count

$$1+2(d-1)=2d-1.$$

A finite flag distinguishes the first extra suffix bit: subtract three capacity units there, then two per further bit. If no extra bit arrives, retain the whole capacity. Root assembly is a bounded operation. This constructs the exact two-point row without an unpaid union. Initialize the global count of negative-budget rows from the signs of these one or two completed budgets with bounded work. The distinguished row thereafter obeys exactly the same insertion and sign-change rules as any dictionary row.

All starting roots are ready before the second right delimiter. Historical records retain their version’s state; no mutable reference or unresolved future pointer is installed. The first two records are a checked startup gate, not a promise of a prebuilt coordinate interface.

4. Online row production and final budget check

A later alias supplies its current row header and, for a new row, constructs $C\ell$ capacity units during its own bits. The target validates the saved prefix and width. Only the $d$ suffix bits service the row insertion. The coherent insertion keeps a strict FIFO of chosen branches and old untouched siblings, and the last-nonfull-sibling cutoff. At the endpoint it captures a fixed-field ready path capsule; taking a child consumes one frame or returns a captured old sibling. It does not recursively interpret a stack of old adapters or unwind $d$ ancestors.

For a genuinely new suffix $z$, let $e$ be the number of old mixed nodes on its path, and $k$ the depth immediately below the last nonfull untouched sibling, or zero when there is none. The established fullness-cutoff argument gives

$$A_d(Y\cup\{z\})=A_d(Y)-e+k.$$

For budget $B=C\ell-A_d(Y)$ initialize signed unary registers $U=V=B$. On each suffix bit, with old-current mixed flag $m$ and old sibling fullness $f$, perform

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

The reset uses updated $U$. After $i$ bits, $U=B+e_i-i$ and $V=B+e_i-k_i$; at the endpoint $V$ is the exact new budget. A duplicate retains the old row and budget. Invalid structural targets do not commit speculative changes. Signed counters permit later recovery after underflow.

Each actual update changes at most one row’s sign. Update the global negative-row count by that sign change, treating the distinguished slot identically. Its zero test at the right boundary checks all final budgets without a row scan. The prefix and suffix rulers are frozen; new globally observed targets never alter another row’s sign.

5. Paid reuse and exact negative observation

For aligned cube views use the inherited asymmetric splice: incoming EMPTY returns the baseline; either operand FULL returns FULL; baseline EMPTY returns the incoming view; otherwise recurse into paired children. Only mixed incoming coordinates can branch, so

$$\operatorname{calls}(B,Y)\le1+2A_d(Y)\le1+2C\ell.$$

Bounded frames charge both calls and returns, observations and allocation. The bound is independent of the baseline’s size and history. It traverses suffix coordinates only; the possibly enormous prefix $P$ is absent from this operation.

Each source retains one committed union and one pending selected row. During the next actual intermediate alias of width $\ell$, a fixed service quantum completes the old pending splice, in parallel with the current alias’s dictionary/equality lookup. At the alias endpoint install the newly selected row as pending. An absent alias contributes EMPTY. A query immediately after any selection reads the committed and pending views directly; it never waits for their splice. The union’s membership is their Boolean OR after prefix/width validation; SAT is the negation of that product entry. This uses a fixed number of readers, regardless of the number of distinct targets, components, rows or selections.

A complement-pair selection followed by a third short alias is therefore covered when the pair passes the ambient budget. For any $Y$, complementing in the full suffix cube preserves $A_d$. The complementary splice costs exactly $1+2A_d(Y)$ under this worker, so the checked alias budget is precisely the required charge. It does not claim to accelerate the coordinate-row family that fails that gate.

6. Strength, cost and remaining frontier

The construction removes the fixed component cap on a useful class without repairing old views. For example, take targets $Pb$ for $b\in\{0,1\}^d$, and choose the first two suffixes as $0^d$ and $1^d$. List all remaining targets later in arbitrary order. They may alternate two ordinary owner aliases, creating unboundedly many singleton components under construction 72’s birth diagnostic. Choose $\ell=d$ and $C=2$. Every row subset has at most $2^d-1$ mixed nodes in general, so an arbitrary subset is not admitted. But birth owners can be chosen by the first suffix bit, in an order alternating the two halves; their final rows are complementary half-cubes, each with mixed count one. Later aliases can name further full prefix cylinders or other rows passing the same budget. These are actual semantic edges; there is no globally enumerated support directory or ignored anchor row. An arbitrarily long $P$ does not increase union work.

For a direct separation from target/name common-width methods, $|P|$ can grow arbitrarily while $d$ and $\ell$ stay fixed. For growth beyond frozen support 71, the first alias can hold just $P0^d$, while later aliases introduce new targets outside its initial row. The new result combines established cube-budget operations with a charged input-learned envelope and startup producer; it is not a new general Boolean-union method.

The stronger gate has a real cost. If observed support is just $U=\{P0^d,P1^d\}$, a singleton row has support-relative mixed count one but ambient suffix mixed count $d$. Thus this construction does not subsume frozen-support 71, and there is no constant conversion from the observed-support combined budget to this ambient budget. Missing cylinders have been charged rather than made free. Early unique routing, bounded components, replay, affine joins, causal sharing and unary coherent algebra retain their separate contracts. Entry 129’s imported state/port bounds and growing alphabet are unchanged; no native lower bound or matching-diagram extraction is asserted.

Next decisive test: eliminate the absent-cylinder charge while allowing support growth after many completed rows. First study sparse suffix supports inside this learned envelope and one late branch insertion. Either maintain the observed-support combined budget and aligned views with a paid repair schedule, or supply a different exact union/readout operation with its own charged deadline. Removing the two-distinct-initial-record gate, variable alias service widths and independently prepared store joins are separate extensions.

Independent finite audit and review record accompany the proof. Finite checks audit semantics and cost identities, not the infinite native scheduling claim.