A local frontier for persistent suffix minima

10 October 2026. Assessment 193. Written native theorem 61 and finite executable evidence. Root admission and novelty are separate.

Current continuation: Ordered suffix reuse handles every fixed number of input-learned final maxima, extending the intermediate two-maximum construction. The theorem and common-maximum proof below remain the worker foundation.

Result and mechanism

Written theorem 61. In the ordinary right-first Horn encoding of the existing language contract, require every nonempty final right row to consist of all binary words whose lengths lie in an interval $[b_v,H]$, with a common input-learned maximum $H$ and positive $b_v$. One fixed deterministic native scaffolding automaton checks this restriction and recognizes the pinned SAT language, with bounded work and allocation per actual input symbol and an immediate final answer.

There is no name/minimum inequality and no bound on selected-name population, minimum diversity or retained versions. Row order, interleaving and duplicate records remain unrestricted. This removes the exponential name/minimum gate of theorem 60. Common maximum, suffix shape and right-first serial access are the scope restrictions of this theorem. Its later extension handles fixed final maximum diversity; growing diversity and independent-store joins remain separate.

For example, endpoints with thousands of bits cannot block a later selected endpoint 2. Nor must a query scan thousands of distinct names that all have endpoint 2. The worker puts new endpoints into its first bucket, advances unfinished endpoints one bucket after each digit, and discards a whole older tail when a smaller endpoint completes.

The useful structural property is adjacent promotion with a discardable upper tail. New work enters age zero; serviced work moves only to the next age; finding a completed minimum removes every strictly larger age. A sparse ordered list therefore changes only its first two buckets. There is no general priority queue, global age search, catenation or deep directory repair.

1. Native primitives and input release

Retain the producer of theorem 60, Sections 1.1-1.2: actual target words build immutable unary rulers and canonical binary numerals, the occupied-run count checks one interval, complete-level counts check every literal word at each occupied width, and the maximum histogram checks common $H$. Omit only its Section 1.3 name/minimum gate. A row’s lower numeral and ruler are prepared on its ordinary right input. Empty rows have a finite marker.

For each left source, the inherited serial dictionary keeps a persistent selected-name trie and the worker root. Traversing an ordinary intermediate name finds its frozen right row and detects repeated selection. Each distinct nonempty row selection releases one job at the delimiter, after lookup. While that name of length $d$ is arriving, the already available worker receives $qd$ service steps. A repeated or absent-row selection creates no job; its spelling may still provide service. No work on the newly discovered endpoint is credited before its release. Source-name routing, trie path capsules and all right-side preparation retain their actual-symbol costs.

A job retains the original lower reader/numeral and a digit cursor. A cursor advances by one digit through the inherited immutable run representation with bounded work. A job’s bucket records its age, the number of digits already observed. The worker needs no arithmetic counter. Numeral production retains the existing counter proof; the new scheduling mechanism uses only unary links and finite digit observations.

2. Sparse buckets with unary gaps

Age $j$ contains a screening job after exactly $j$ observed digits. If its numeral ends on the next observation, its bit length is $j+1$. All jobs at strictly larger ages have strictly longer numerals and hence strictly larger endpoint values.

Each bucket is one fixed-field record containing:

• a unary ruler for its absolute age;
• a unary ruler for the positive gap to the next bucket, and that bucket’s pointer;
• a stack of screening jobs;
• an optional active digit comparison;
• an optional completed minimum with its original reader roots.

Buckets are strictly increasing in age. Every retained bucket has a job, comparison or minimum. At most one bucket has a minimum, and it is the last bucket. A comparison can occur only in that minimum bucket. The empty worker is a null root. A worker is idle exactly when its head has neither jobs nor a comparison; the invariants then make it either empty or one minimum-only bucket.

Age and gap values are unary linked roots, not unbounded labels. The implementation tests only whether an age ruler is empty or a gap has one cell. It never compares arbitrary ages. It retains one constant unit root for gap one.

Release

If the worker is empty, create an age-zero bucket. If its head has age zero, push the new job onto its job stack, preserving any active comparison. Otherwise prepend an age-zero bucket whose gap is the old head’s absolute-age ruler. This shares a prepared unary root and performs no subtraction or traversal.

Screening and adjacent promotion

Service the head bucket. An active comparison takes precedence; otherwise observe one digit of its first job. If the numeral has not ended, move the job from age $j$ to $j+1$:

• If the current bucket has a minimum, discard the job: its unfinished numeral is longer than every numeral that completed in this bucket.
• Otherwise inspect the next gap. If it is one, push the advanced job into the next bucket, copying that bucket while preserving its comparison, minimum and following pointer.
• If there is no next bucket or the gap exceeds one, create age $j+1$ by pushing one cell onto the current age ruler. With an old next bucket, its new gap is the old gap with one cell popped; otherwise it has no successor.

If other jobs remain in the current bucket, retain it with gap one and the promoted successor. If it becomes empty, return that successor directly. Only the head, its successor and bounded stack/cursor views are inspected. There is no walk through empty buckets because no empty bucket is retained.

Completion and reduction

If a numeral completes in a head bucket without a minimum, keep it as the minimum and discard the entire following chain. All endpoints in that chain have strictly longer numerals. Other jobs at the current age remain.

If the head already has a minimum, start a digitwise comparison between that minimum and the completed endpoint. One service step reads the next low-order digit of each operand and retains the sign of the most recent unequal digits. When both end, keep the smaller original endpoint and clear the comparison. Both numerals have $j+1$ digits, so this takes $j+1$ comparison steps. There is no integer-order or completed-set oracle.

3. Why interruptions preserve the current version

A new age-zero bucket can suspend the old head, including an active comparison. Promotions below the old head create or update only local successors. On reaching its age, a promoted job is pushed into that bucket’s job stack while its active comparison is preserved. The comparison is still serviced before any newly arrived same-age screening job.

If a lower-age endpoint completes first, it discards the whole higher-age tail. Both operands of any suspended comparison there are larger, so discarding that comparison is sound. Otherwise no operation has changed the minimum used by the suspended comparison. Its eventual commit cannot overwrite a newer smaller minimum.

Every update returns a new root built from boundedly many current records. There is no delayed replacement of an old directory root. Dropping a tail changes only the new version; old versions still point to their original immutable buckets. New arrivals are not merged by replaying a log, and there is no concatenation spine to traverse. This discharges the concrete failure in the preceding attempt by changing the representation. The dyadic prototype was unnecessary once adjacent promotion became local: exact digit ages also work, with no scheduling counter.

Induction on release and service proves the bucket invariants and that the minimum of all represented endpoints equals the minimum of all selected nonempty rows. Dropping a job or a tail preserves that minimum by strict numeral length. A completed digit comparison preserves it by exact binary order. Empty and duplicate cases preserve it directly.

4. Names pay the unfinished joint work

Use normalized service steps, each of which is the bounded record operation just described. Fix a positive digit cutoff $k$. A newly released job needs at most $k$ screening steps through ages $0,\ldots,k-1$, and at most one comparison of at most $k$ steps. Promotion and comparison setup occur in the screening step’s bounded batch. Thus $C_k=2k$ is a per-job envelope.

Assign each job $C_k$ credits for this work. Every nonidle service step addresses the least age. It consumes one credit through age $k-1$ whenever such work remains. Promotion to age $k$, completion and tail cancellation discard unused credits. Interruptions do not restart digit comparisons. While positive credit remains, higher-age work cannot take service from it.

With $q$ service steps per ordinary name bit, the last-busy-period bound for distinct nonempty binary names gives

$$W_k\le B_q(2k):=2k+\sum_{d\ge1}2^d(2k-qd)_+ \le2k+4q2^{2k/q}.$$

Here $W_k$ bounds remaining work through age $k-1$ at any selection boundary. There are at most $2^d$ distinct names of length $d$; duplicate selections add no credit. The first release of a busy period contributes at most $2k$, and each later name contributes at most $(2k-qd)_+$. This proves the bound for arbitrarily many selected rows and arbitrary retained histories. Restricting an interleaved history to one source gives the same argument; unrelated-source input is not credited to that worker.

Tail cancellation gives a useful stronger consequence: if some selected endpoint has at most $k$ bits, draining work through age $k-1$ makes the entire worker idle. Completion of a shortest numeral discards all higher buckets, and the remaining work is all within the cutoff. Thus final minimum observation is a bounded head test. No age-cutoff selector or global coverage scan is needed in a query.

5. Every short query gets its answer on time

Take $q=16$ normalized service steps per selection-name bit and $Q=256$ per query-target bit. These are fixed constants, not input-dependent parallelism. A query forks the retrieved worker root and services it continuously until idle. It does not predict the final target length or run an EOF cleanup.

For the proof, let $b$ be the true selected minimum and take $k=\max(4,\lfloor\log_2 b\rfloor+1)$. Its numeral has at most $k$ bits. Therefore

$$W_k\le2k+64\,2^{k/8}<Q\,2^{k-4}.$$

After division by $2^{k-4}$, the first term is at most 8 and the second is at most 128 for all $k\ge4$: $7k/8\ge3$. Both fit below $Q$. The worker becomes idle within $2^{k-4}$ target symbols. For $b\le15$, it becomes idle in the first target batch. Empty selections are detected immediately.

At discovery time $t$, attach the original lower ruler and repair its lag against the actual query prefix using four fixed repair steps per target symbol, including the birth batch, as in theorem 60. For $k>4$, $b\ge2^{k-1}$ and $t\le2^{k-4}$; even ignoring birth service, repair finishes by $t+\lceil t/3\rceil<b$. For $k=4$, the one-symbol lag is repaired in the birth batch, including $b=1$. Until alignment the false answer is correct. Thereafter the lower reader accepts exactly when target length is at least $b$. An independent common-upper reader rejects beyond $H$. At an empty target, positive minima give the immediate false membership answer.

The controller answers membership exactly at every target prefix and complements that bit for pinned Horn SAT. These logarithms and cutoffs are only proof variables: the implementation runs a fixed service batch and tests whether the head is idle. It needs no query-stage clock, integer age comparison or supplied future length.

6. Native resource and assurance boundary

Fix the existing numeral cursor, dictionary, ruler and simultaneous-record implementations. Each normalized worker step inspects a fixed tuple of roots, the first two buckets, fixed stack heads and one digit view per operand. Apart from inherited digit-cursor work, a service step allocates at most five of the displayed records; release allocates at most four. Their arities are bounded: the bucket has six fields. Absolute ages use one new unary cell at promotion; gaps use shared roots or one-cell tails. No address equality, metadata order, mutable cell, delayed future or timing channel is used.

If the inherited primitive views have fixed radius $r_0$ and allocation bound $a_0$, the worker adds only a fixed number of record fields and pointer hops. Unrolling the fixed $q$ and $Q$ service batches gives a fixed finite observable record plan. The inherited chronological simultaneous-record compiler supplies one fixed degree and radius, finite labels/control and old-top updates for that plan. Constants depend only on these fixed implementations and service rates, not on names, ages, endpoints, $H$ or input length. Initialization contains only the parser state, empty roots and the one-cell gap ruler. This is one fixed automaton, not a nonuniform family indexed by the input.

Across actual encoded length $N$, right preparation, ordinary-name routing, selected-trie copies, worker service, retained versions, query forks, lag repair and output use $O(N)$ logical operations and storage. Previously paid input is not reusable service credit. All fresh records are paid in the current symbol’s fixed batch. Physical scaffold history has $N+1$ nodes under the inherited packing convention; explicitly writing its pointers takes $O(N\log(N+2))$ bits. Its recognition-to-PEG consequence concerns reversal.

The written proof supplies the all-length construction. The executable audit uses explicit unary age/gap links, immutable buckets and stacks, and digitwise comparisons. The worker has no arithmetic counter, priority selector or endpoint-order oracle. Independent whole-state inspection and direct integer minima occur outside the worker. Query lag and original unary reader lengths are modeled arithmetically in the separate audit. Right-row validation and scaffold packing retain their inherited proof scope. The earlier ideal dyadic audit preserves the intermediate workload and failure checks; it is not the final worker.

This is a specialization to monotone adjacent promotion and upper-tail deletion, extending the Lab’s counter, dictionary and reader mechanisms. The comparison-based heap results in review 190 assume a completed ordering callback; this construction schedules the endpoint digits and uses structural bucket position. No general heap improvement or external novelty priority is claimed.

7. Next structural boundary

The entry-129 full-relation lower bounds keep their growing alphabet and matching/positive-path hypotheses. This theorem treats a restricted nested row family, not all relation products or a constant-port realization of their full monoid. Its contribution is a paid readout for that family, not a claim that the semantic minimum alone was enough.

A suffix union is determined by its smallest lower endpoint and common maximum. That is why a shorter completed numeral can erase a whole older tail. With different maxima or interior intervals, a numerically larger endpoint may still carry indispensable coverage, so the same cancellation is not sound.

The next test at assessment 193, completed by theorem 62, was two final maxima with suffix rows: can the frontier retain the necessary lower/upper coverage without restoring an unbounded set of active minima or hiding endpoint comparisons? Start with a short interval that supplies the smallest minimum but ends before a later interval begins. Charge the new coverage state and every query deadline; keep independent-store joins separate.

Source custody: one maintained proof and checker. Claim mapping: written native theorem 61, not root admission. Evidence: the argument, immutable audit and inherited native primitives. Failures: earlier FIFO, newest-only, stale-directory and generic catenation routes retain their scoped statements; sparse adjacent promotion replaces their missing operation in this subclass. Frontier: heterogeneous upper endpoints and general interval coverage. Reader synthesis and Site representation: generated styled proof and highlighted exact-download source, with publication receipts in integration state. The prior SAT, replay, affine and causal-algebra results remain separate controls.