Short names make suffix reuse locally readable

10 October 2026. Assessment 189. Written native theorem 60, with finite semantic and scheduling evidence. No root-ledger admission or priority claim.

Result and motivation

A short query should not have to inspect arbitrarily many completed computations. One way to guarantee this is to relate each computation’s ordinary name to the earliest query it can affect. We make that relation explicit and check it during the input.

Written theorem 60. Fix an integer $c\ge2$. Use the ordinary right-first Horn encoding and terminal pins of the existing language contract. Require every nonempty final right row named $v$ to contain exactly all binary words whose lengths lie in an interval $[b_v,H]$, with one common input-learned maximum $H$, and require

$$b_v\ge 2^{c|v|}.$$

Names are nonempty ordinary binary strings. One fixed deterministic native scaffolding automaton, depending only on $c$, checks these restrictions and recognizes the pinned SAT language with bounded work and allocation per actual input symbol and immediate final output. Within these gates, row order, interleaving and duplicates are unrestricted; there is no fixed bound on selected-name population, minimum diversity or retained versions. All input, including the complete binary levels, is charged at its actual encoded length $N$.

The rows have arbitrarily long initial missing intervals. The construction is a subclass result: its exponential name/minimum restriction is essential to the proof. It does not solve unrestricted missing intervals, different final maxima, general radial profiles or independent-store joins. No padding or encoding conversion is asserted. Its PEG consequence concerns the reversal of this checked native language.

The mechanism is different from completing a minimum at selection time. Keep the selected rows in their ordinary-name trie. A query progressively examines only those names that could affect its current length. For a query of length $n$, the inequality implies $|v|\le(\log_2 n)/c$ for every relevant row. There are at most $2n^{1/c}$ such nonempty names. This population bound pays actual trie traversal and endpoint observations; it is not an information-size lower bound or a free filtered lookup.

1. Prepare and check the right rows on their actual words

1.1 Minimum and maximum exports

For each target word of length $n$, build its unary ruler and canonical run-encoded binary numeral while its bits arrive. Increment the inherited bounded-local numeral counter once per bit. In parallel, advance a cursor down the row’s old minimum ruler. If that cursor empties by the delimiter, the old minimum is at most $n$ and remains unchanged. Otherwise the new word is shorter: retain the ruler and numeral just built. The first word initializes them. Equality leaves the old roots valid. No old ruler is copied or subtracted at a delimiter.

Maintain the maximum and the common-maximum histogram using the input-dominated maximum construction. A word increasing the maximum is long enough to traverse its old and new class positions while it arrives. At the right boundary, the histogram must have at most one nonempty maximum class. Empty right input is handled separately. These are inherited charged operations, not ready handles supplied by the input.

1.2 Exact suffix shape and literal coverage

The existing unary width dictionary distinguishes occupied widths from absent widths. At the first target at an absent width $n$, its predecessor and successor occupancy are available from the final path frame and one bounded child view. Treat width zero as absent. Let $C_v$ count occupied runs in row $v$. On this first occupancy update,

$$C_v\gets C_v+1-p-s,$$

where $p,s\in\{0,1\}$ are the predecessor and successor occupancy flags. An isolated width creates a run, an extension preserves the count, and a bridge joins two runs. The count changes only by $-1,0,1$, so a unit stack suffices. In the bridge case there were two distinct neighboring runs, making the decrement legal. Duplicates and later words at the same width leave $C_v$ unchanged.

Maintain a global unit stack counting rows with $C_v\ge2$, adjusting it on transitions across the one/two boundary using two-cell observations of the row counter. At the right boundary this stack is empty exactly when every nonempty occupied-width set is one interval, necessarily $[b_v,H_v]$. This admits arbitrary intermediate numbers of gaps and avoids a scan of the final missing prefix.

Separately retain the complete-level validator: distinct pairs at occupied width $n$ are counted against $2^n$, with the capacity representation prepared on that width’s first actual word. Its global incomplete-level counter must be zero at the right boundary. Thus the gate checks every binary word at each occupied width, not merely an interval of observed lengths. Together with the common-maximum gate it proves exactly the promised row shape.

1.3 Check the name/minimum restriction without constructing an exponential ruler

While each ordinary right name $v$ is spelled, construct a unit stack of length $e=c|v|$ using $c$ fixed pushes per symbol. During its target word, increment the target-length numeral. A positive counter value is a power of two exactly when its run encoding consists of one high 1 with an optional low zero run. Bounded run-head and unit-stack observations recognize this event.

At each such event, pop one unit from a private copy of the exponent stack while it is nonempty. If the event occurs when it is already empty, set a persistent finite large-enough flag. Events at lengths $2^0,2^1,\ldots,2^{e-1}$ consume the $e$ units; the event at $2^e$ sets the flag. Require it at the target delimiter. This checks $n\ge2^{c|v|}$ on every right record. Since the final minimum is the smallest such $n$, these checks are equivalent to the theorem’s name/minimum condition. No stack of length $2^e$ is built, and no large-number test is deferred until the delimiter.

All row preparation and gates use a fixed tuple of inherited counters, dictionaries and cursors. The complete encoded input is checked; no suffix promise or externally prepared decomposition is assumed.

2. Selection stores a trie, not a completed minimum

For each left source, use the existing pointer-valued serial dictionary to retain a persistent trie of distinct selected intermediate names. During an ordinary name’s spelling, traverse its selected-name trie and the frozen right dictionary. At its delimiter, attach the located row’s prepared lower ruler/numeral to the selected terminal, or an absent-row marker. Copy the traversed trie path through the established input-funded capsule. Repeated names keep the same selected terminal.

This needs no endpoint comparison, class insertion, numeric sorting or endpoint-based deduplication after lookup. Different names with equal rows remain different trie terminals; their number is paid by the ordinary binary-name population bound. Shared prefixes are traversed as real trie edges. The ready endpoint roots were constructed during the right input, and finding their row costs the actual left name.

A query obtains this frozen selected-trie root while its source name arrives. Its target bits start the following worker. Retaining or later extending another version does not alter that query’s root.

3. A capped stage has bounded actual work

For an integer $k\ge4$, a stage explores the selected trie only to depth

$$D=\lfloor k/c\rfloor.$$

Depth-first traversal uses an immutable stack of bounded frames and a unary depth-fuel root. On a terminal, read at most $k$ bits of its row’s numeral, using a unary cap. If the numeral still has a bit after that cap, discard this row for this stage. Otherwise its endpoint is exactly known to lie below $2^k$. Compare it with the stage’s best endpoint by the inherited least-significant-bit-first comparator, retaining the smaller row’s original ruler and numeral. Both complete numerals have at most $k$ bits. Pointer identity and integer-address operations are never used.

The traversal visits at most $2^{D+1}-1$ nodes. A visited terminal needs at most $k$ capped digit steps and at most $k$ comparison steps, plus bounded setup and completion. For one fixed implementation constant $A$, chosen large enough to include stack transitions, cursor views, allocation and stage setup,

$$W_k\le A(k+1)2^{\lfloor k/c\rfloor+1}.$$

A longer numeral cannot monopolize the worker: the cap is tested through its own paid cursor, after which traversal resumes. Each stage restarts from the selected-trie root; this repeated work is included in $W_k$.

At completion, the stage has considered every selected row with $b_v<2^k$. Indeed, $c|v|\le\log_2 b_v<k$ places its terminal within depth $D$, and its numeral ends within the cap. Conversely, a retained endpoint is an actual selected row. If the stage finds any endpoint, its minimum is the true global minimum: all omitted endpoints are at least $2^k$. If it finds none, all selected rows start at or beyond $2^k$.

4. Schedule discovery before its first possible positive answer

Start stage $k=4$ on the first target bit. Thereafter start stage $k$ at query position

$$T_k=2^{k-4}.$$

Use the target counter’s bounded power-of-two test to recognize these positions. Keep a unary $k$ ruler, incremented once per stage, and a unary $D$ ruler incremented every $c$ stages using a fixed residue in control. Initialization has constant size. No unbounded exponent calculation occurs in a transition.

Give the active worker $Q=64A$ elementary steps per target symbol, including its birth symbol. For every $c\ge2$ and $k\ge4$,

$$\frac{W_k}{T_k} \le A(k+1)2^{\lfloor k/2\rfloor+5-k}\le40A.$$

For even $k$, the last expression is maximal at $k=4$; for odd $k$, at $k=5$. Increasing $k$ by two multiplies it by $(k+3)/(2(k+1))<1$. Thus stage $k$ finishes no later than

$$T_k+\lceil W_k/Q\rceil-1<2T_k.$$

The next stage cannot collide with unfinished work. The first stage finishes in its birth batch because $W_4\le40A<Q$.

If a stage completes with no endpoint, continue with the next stage when its clock event arrives. If it finds the minimum, stop all subsequent stages and align the retained lower ruler. Until discovery, answer false. This is safe: for $k>4$, the preceding empty stage certified $b_v\ge2^{k-1}$ for every row, whereas the current stage finishes before $2^{k-3}$. In the first stage every row starts at least at $2^c\ge4$, and its work finishes at query position one.

Empty selections continue to answer false; their stage work is still bounded. No scan at EOF is needed to determine emptiness.

5. Align the final reader, with its replay charged

At discovery position $t$, retain the actual query-prefix unary root as lag and initialize the lower ruler at the discovered minimum $b$. Grant four repair steps in the birth batch. Each later target bit adds one lag unit, and a repair step removes one lag unit while advancing the lower ruler by one. When lag reaches zero, the reader is aligned; from then on it advances once per target bit. All these are explicit unit-stack operations with bounded allocation. No prefix is traversed for free.

Alignment finishes by $t+\lceil t/3\rceil$ even if birth service is ignored. For $k>4$, $t<2^{k-3}$ and $b\ge2^{k-1}$, so alignment is strictly before position $b$. At the first stage $t=1$ and birth service aligns immediately, again before $b\ge4$. During unfinished repair the false answer remains correct. Once aligned, the lower reader accepts exactly at and beyond $b$.

An independent reader for the common upper ruler $H$ starts at query position zero and rejects exactly beyond $H$. Therefore every query prefix of length $n$ has the exact membership answer $b\le n\le H$, or false if no selected row exists. Complement that membership bit for the inherited pinned Horn SAT readout. The answer is ready on the final symbol; no eventual query length is known in advance.

6. Native resources, scope and evidence

The algorithm uses one stage worker, one best endpoint, one lower reader, one upper reader, and fixed parsing/counter roots. The DFS stack and selected trie may grow, but their edges, frames, labels and local operations have fixed size. Unary stage/depth fuel is prepared on the actual query clock. Each target symbol performs a fixed worker batch plus bounded counter and reader actions; every stage visit and discarded long numeral is charged to that batch.

The inherited simultaneous-record compiler fixes degree, radius, finite control and chronological old-top updates. All newly allocated pointers refer to already available roots. Initialization is constant. Across actual encoded length $N$, preparation, dictionary routing, selected-trie path copies, stage restarts, old-storage observations, discarded work, retained versions and output use $O_c(N)$ logical work and storage. The physical scaffold has $N+1$ nodes under that compiler, with $O_c(N\log(N+2))$ explicit pointer bits. This is one fixed automaton for each fixed $c$, not a machine chosen from the input’s $H$ or name population.

The theorem is serial right-first reuse. It supplies no constant-cost join of separately owned stores and no recognition transfer without the existing reversal and encoding checks. Entry129’s imported matching/positive-path bounds retain their original hypotheses. This construction uses branching, shared prepared roots, bounded negative observations and a checked bound on the number of names that can affect short queries. It neither extracts a small matching diagram nor solves unrestricted relation composition.

The finite audit implements immutable worker states, capped numeral observations, bitwise comparisons, retained trie/query versions and paid reader lag. It compares every tested query prefix with an independent direct minimum oracle. The producer’s component-count update is checked against independent occupied sets. Python integers and tuples model cursors and persistent frames; measured Python runtime is not a native complexity claim. The all-length bounds above supply that claim.

The important limitation is now explicit. Ordinary names alone do not bound the number of rows relevant to a short query. Here the input-checked inequality supplies that bound, and actual trie traversal realizes it. Removing the inequality requires a different paid index or a stronger readout; simply granting a list of relevant rows would assume the hard part. The earlier FIFO obstruction remains valid for its restricted contract and is escaped by this capped, name-indexed search.

Continuation: Review 190 has completed the priority/search comparison proposed by this construction. It isolates a threshold-refining selected-minimum accumulator as the next target. The current checkpoint retains the exact test and resource obligations. Common maximum and suffix shape remain separate restrictions; arbitrary interior intervals and independent-store joins stay open.

Subsequent extension, 10 October 2026: theorem 61 removes this note’s exponential name/minimum gate for the same common-maximum suffix class. The present construction and proof remain valid as a restricted predecessor.