Interval reuse through persistent length bands

10 October 2026. Assessment 198. Written native theorem 64, independently reviewed. This extends the maintained suffix machinery; root admission and external novelty remain separate.

Current continuation: Scale-sparse band reuse permits an input-growing number of separated components, with at most a fixed number of partial bands in each doubling block of band indices. The theorem below and its dated next test remain intact.

Statement and payoff

Theorem 64 removes the final maximum-diversity restriction from theorem 63. In its same ordinary right-first Horn encoding, require each nonempty final right row to contain exactly every binary word whose length lies in one interval $[b_v,H_v]$, with $1\le b_v\le H_v$. One fixed machine checks this condition and recognizes pinned SAT with bounded work and allocation per actual symbol, including the last symbol. Names, endpoint sizes, row and selection populations, interleaving, duplicates and retained versions are unrestricted.

For example, selected rows $[1,1]$, $[4,4]$ and $[2^{500},2^{500}+3]$ must answer a length-four query positively and a length-three query negatively, even while the huge endpoint is unfinished. Keeping only the smallest endpoint loses the answer at four. The construction preserves both short coverage and the suspended large row.

The structural property is that an interval has at most two partial intersections with the bands

$$I_k=[2^{k-1},2^k-1],\qquad k\ge1.$$

Every intervening band is full. There can be arbitrarily many union components, but a row needs only linear work through band $k$. A persistent worker services smaller bands first. It retains completed coverage rather than discarding every larger lower endpoint, as the common-maximum minimum worker could do.

This remains serial reuse of checked prepared rows, not composition of independently supplied stores. The language consequence is a PEG for the reversal of the checked language. Entry 129’s full-relation alphabet and matching/positive-path lower-bound hypotheses are unchanged.

1. Inherited preparation and fixed primitives

Retain the ordinary-name dictionaries, per-source duplicate suppression, literal complete-level and one-interval validators, prepared lower/upper unary rulers and canonical linked least-significant-first binary numerals from the suffix producer. Omit the common-maximum and final-diversity gates. No maximum palette is exported or supplied.

Use only empty, end views, insertion/removal at an end and catenation from the strict persistent deque primitive extracted in review 195. The deque is a fixed-field strict list construction. No search, split, measured tree, comparison callback, address equality, laziness or memoization is imported. A strict FIFO supplies the query output buffer. Both operate on already available roots; preparation and every operation are charged here.

A coverage tree for band $I_k$ is a binary trie of height $k-1$, indexed by the remaining bits after the numeral’s leading one. Its labels are EMPTY, FULL or BRANCH. EMPTY and FULL describe uniform subtrees, including implicit descendants. BRANCH stores two roots. Union insertion may collapse two FULL children to FULL using labels, without pointer identity. No population count or arithmetic sum is stored.

2. A resumable boundary insertion

Given a band tree and completed endpoint numerals of the appropriate width, insert a prefix, suffix or interval. Reverse each needed linked numeral into a fresh most-significant-first list, one digit per step, and remove the leading one. At most two reversals are needed.

Perform the usual recursive range-cover update with an explicit immutable continuation stack. At a node, an absent lower bound means all values from the subtree’s left edge; an absent upper bound means all values through its right edge. A FULL node, a node with both bounds absent, or a height-zero leaf reached by a nonempty range returns FULL. Otherwise compare the next bound bits. Equal bits descend into that one child and retain the other. Unequal bits recurse into a suffix of the left child and a prefix of the right child. A return builds one parent or collapses two FULL children. The frame stores only the other child, remaining bound roots, height root, phase and an already returned child.

There are at most two boundary spines. At each depth, each spine introduces at most one full sibling. Thus there are at most $4k+1$ task entries and at most that many returns, plus at most $2k+2$ reversal/setup steps. A conservative bound of $16k+16$ normalized steps suffices. Each step has bounded old-field observations and allocation. The height is a unary root, not a numeric label. A whole-band insertion sets FULL in one bounded step.

Only one insertion is active in a given band. Its old tree and continuation remain inside that band’s record. New jobs may join that band while it is suspended, but cannot alter its tree until the active insertion commits. There is no delayed replacement of a global directory root.

3. Ordered service without stale-prefix replacement

Keep a dense sequence of band records, starting at band 1, in two strict persistent deques $P,S$. The prefix $P$ contains records with no unfinished jobs; $S$ begins at the current service position. A band record contains its unary height, coverage root, job stack and optional boundary-insertion continuation. Records can be empty of both coverage and work; retaining them avoids combining long unary gaps. Only the largest already visited band is materialized. A promotion creates the next record when needed.

A row job stores its original lower/upper numeral roots, their advancing cursors and a finite phase: before the lower endpoint ends, or after that event. Each visit to band $k$ consumes the next upper digit and, until its end, the next lower digit. Since $b_v\le H_v$, the upper numeral cannot end at an earlier band than the lower numeral.

• Before the lower numeral ends, this band’s intersection is empty. Promote the job to the next band.
• When the lower numeral first ends, insert the suffix from $b_v$ through this band’s end if the upper numeral continues. If both end together, insert $[b_v,H_v]$ and finish the job.
• After the lower numeral has ended, a continuing upper numeral makes this whole band FULL. When the upper numeral ends, insert the prefix through $H_v$ and finish the job.

Promotion occurs after any boundary insertion commits. It pushes the continuation job into the next band without disturbing that band’s active insertion. If other jobs remain at the current band, keep servicing them. An active insertion takes precedence over those jobs. When a record has no work, move it from the front of $S$ to the back of $P$ in one step. If $S$ becomes empty, all jobs are finished.

At a new distinct nonempty row release, reconstruct the current sequence by the one operation $P\mathbin{\|}S$, reset $P$ to empty, and push the new job into band 1. Create band 1 if the sequence was empty. Catenation retains the current versions of all records, including every suspended insertion. It does not adopt an old snapshot after later changes. Repeated or absent-row selections release no job.

Version invariant. The concatenation $P\mathbin{\|}S$ contains each materialized band once, in consecutive order. Every unfinished row is in exactly one job stack or insertion continuation. Its lower bands have already received their exact intersections. Each coverage root is the union of the intersections committed to that band. Each active insertion is based on that same band’s current committed root, which remains unchanged until it returns.

Release, digit screening, promotion, insertion microsteps and passing a finished record preserve this invariant. A lower-band arrival resets the service position but leaves higher-band continuations intact. When its promotion reaches an occupied higher band, it joins the waiting stack rather than replacing that continuation. This is the same useful ownership property as the sparse-age worker, with a persistent deque paying reconstruction of its finished prefix. No mutable logical cell or external ready handle is assumed.

4. A linear amount of unfinished work through every band

For a fixed analysis cutoff $k$, let $W_k$ be the number of service microsteps needed, with no further arrivals, to pass band $k$, or finish all jobs and certify all remaining bands empty. Work at bands beyond $k$ is irrelevant to this stopping condition.

One row consumes at most $k$ paired digit-screening steps through band $k$, at most $k$ promotions/whole-band actions, and at most two boundary insertions, each at a band of index at most $k$. The insertion bound above gives at most $32k+32$ steps for those two operations. Constant phase transitions fit within another $8k+8$. A new release can force the worker to revisit at most $k$ finished prefix records. It does not restart any insertion or digit cursor. Adding coverage cannot increase the work of pre-existing waiting insertions: their boundary paths are determined by their own endpoints, independently of tree shape, and additional FULL labels can only shorten those paths. Existing jobs keep their relative service order; an already active insertion retains its own unchanged base tree. Removing the new row’s operations from the coupled execution leaves the old work, possibly shortened by those FULL shortcuts, and at most $k$ repeated prefix passes. Therefore a conservative common bound

$$C_k=256k$$

covers the increase in $W_k$ caused by a release, including renewed prefix traversal. An ordinary service step decreases positive $W_k$ by one: service cannot enter a larger band while unfinished work at a smaller band survives. If the worker has already passed the cutoff, higher-band work does not increase $W_k$.

For fixed $q$ microsteps during each subsequent ordinary intermediate-name bit, the inherited distinct-name busy-period argument gives

$$W_k\le C_k+\sum_{d\ge1}2^d(C_k-qd)_+ \le C_k+4q2^{C_k/q}.$$

The first job in a busy period contributes at most $C_k$; each later distinct name of length $d$ contributes at most $(C_k-qd)_+$. Missing or duplicate selections add no work. Service before a name’s delimiter belongs only to previously released work. Restricting an interleaved input to a single source preserves this argument. These are proof credits, not stored counters or banked preparation time.

Put $c=256$, $q=64c$ and $Q=1024c$. For $k\ge4$,

$$W_k\le ck+256c2^{k/64}<Q2^{k-4}.$$

After division by $c2^{k-4}$, both summands decrease for $k\ge4$, and their sum at 4 is less than 272, below 1024. A query servicing $Q$ steps per target bit therefore seals bands through $k$ by time $2^{k-4}$. Bands 1 through 4 are sealed in its first service batch. The machine never computes this cutoff.

5. Sealed coverage becomes an output stream

A query forks the selected receipt. There are no new row releases in this fork. Its existing $P$ is retained as the same strict deque of sealed band records, and its $S$ remains the worker’s pending sequence. Consume records by a front view, reading each stored tree and height; no queue conversion or mapping is performed. Whenever the worker passes a finished record, append that record to the same deque in band order. No later job can return to a sealed band. When the worker finishes, a terminal marker certifies all higher bands EMPTY. Previously retained versions keep their own roots and are unaffected.

A reader takes sealed band records from that deque in order. It enumerates all leaves of each band’s conceptual full binary tree, from left to right. EMPTY and FULL propagate their finite label to virtual children; BRANCH exposes its actual children. An explicit depth-first stack and unary height make each enter, emit or return a bounded record step. Uniform subtrees need no exponential preallocation: virtual children are created only by these charged reader steps. Every leaf emits its Boolean into a strict FIFO.

For $a_k=2^{k-1}$ leaves, the complete traversal, band handoff and output enqueues use at most $16a_k$ normalized steps. No endpoint arithmetic is performed by the reader. Running 1024 reader steps per target symbol is sufficient. In the first query batch, the worker seals the first four bands (or certifies an earlier all-empty tail), and the reader can produce their first 15 answers: $16(1+2+4+8)<1024$.

Let $F_k$ be the target time by which all answers of band $k$ have been generated. For $k\ge5$, the sealing bound is $a_k/8$. If $F_{k-1}\le a_k/8$, then

$$F_k\le\max(\lceil a_k/8\rceil,F_{k-1}) +\left\lceil16a_k/1024\right\rceil\le a_k/4.$$

Here $a_k\ge16$, and the powers of two make the final inequality immediate. The base $F_4\le1\le a_4/4$ establishes the induction. A reader that was temporarily waiting uses no saved service credit; this recurrence charges only actual service after both prerequisites are available. Thus every whole band is generated before its first needed query position, apart from the first batch already handled explicitly.

After the service and reader batches, pop one answer for the current target bit. The target’s contents do not affect interval membership, but the parser retains its literal syntax checks. Empty targets have false membership since all lower endpoints are positive. After an all-empty tail marker, consume any buffered earlier answers and then emit false forever. Complement the membership bit for pinned Horn SAT at the required final delimiter. There is no EOF work or prediction of the final target length.

6. Native resource contract and limits

Fix the inherited producer, dictionary, strict deque/FIFO and simultaneous-record implementations. All new records have finitely many pointer fields, finite labels and control. Microsteps inspect only fixed views of the first two pending band records, a digit, a stack frame or queue ends. All references target old roots or bounded same-batch records. The finite simultaneous-record compiler therefore fixes a degree, radius and old-top transition rule, independent of endpoints, number of bands, component count and encoded length.

Initialization has empty roots and finite parser/phase flags. Ordinary right input pays row validation and endpoint preparation. Actual name bits pay only the current receipt’s fixed service batch; release occurs at its delimiter. Target bits pay worker, traversal, FIFO and final answer work. Every allocation, old-storage observation, routing step, suspension, fork, reversed digit, virtual tree node and output record is included. Across actual length $N$, logical work/storage are $O(N)$ with fixed constants. The inherited physical packing uses $N+1$ scaffold nodes; writing explicit pointers costs $O(N\log(N+2))$ bits. No padding, advice, supplied decomposition, uncharged preprocessing, timing/address/metadata channel or free EOF drain is used.

The crucial difference from an endpoint-event sum is that the band payload stores Boolean coverage. It never adds unbounded multiplicities at query time. The difference from an eager rank directory is that a whole finished prefix is retained as a deque and restored at a release, while each band’s active insertion owns its own root. The difference from theorem 63 is that no fixed number of simultaneous range readers is needed: a single reader enumerates sealed bands using the query’s actual length.

The construction is restricted to complete interval rows. It does not show that arbitrary row languages admit the same linear band-intersection workload. Replay and causal sharing preserve versions but do not waive per-fork service. Affine-fragment and unary coherent controls do not grant independent-store joins. The natural unrestricted SAT/scaffold boundary remains open.

7. The charged band criterion

The scheduling argument has a useful sufficient-condition form. Fix integer constants $c,d\ge1$. Retain distinct nonempty binary selection names, so there are at most $2^m$ names of length $m$. Suppose a checked ordinary-input producer and its native name dictionaries provide the following local operations, with all preparation charged before reuse:

1. A new distinct selection releases one job by bounded local work. For every cutoff $k$, it increases the remaining work to seal bands through $k$ by at most $ck$.
2. Each service step reduces positive remaining work by one. Finished bands form an ordered prefix, and a query fork without further releases can transfer each newly sealed band to its reader in bounded local work. If all jobs finish before a band is materialized, a locally readable EMPTY-tail certificate supplies the remaining false answers.
3. A sealed band of $2^{k-1}$ positions has an explicit local enumerator costing at most $d2^{k-1}$ steps, including handoff and Boolean-output insertion. Its bit at position $n$ is exactly selected-row union membership for every target word of length $n$. Thus this form of the criterion requires length-invariant row membership; arbitrary word languages need an additional charged content-sensitive mechanism. Its stack, routing and every old observation have fixed local implementations.
4. These operations preserve immutable versions and use fixed degree, radius, labels and control. Initialization, ordinary syntax checks, dictionary access and output are already paid native operations.

Then fixed service rates $q=64c$ per selection-name bit, $Q=1024c$ per query bit and reader rate $64d$ per query bit give strict native readout. The distinct-name busy-period bound and sealing estimate of Section 4 apply verbatim. The first reader batch can enumerate the first 15 positions because $15d<64d$. Later bands satisfy the same recurrence as Section 5, with traversal time at most $\lceil a_k/64\rceil$. Thus the query never waits beyond its symbol deadline.

This is a conditional transfer from a charged local interface, not from semantic equivalence or storage size alone. The interval construction verifies all four premises with $c=256,d=16$, including its producer and persistent data structures. A broader row class must separately supply those operations and their release bound; merely providing interval lists or ready endpoint handles does not meet the criterion. Independent-store composition is not a premise or consequence.

8. Evidence, failed routes and next test

The finite immutable audit checks resumable band insertions, lower-band interruptions, completed-prefix restoration, query streams, negative gaps and retained versions against an independent direct interval-union oracle. Tuple band deques and the query-local output FIFO stand for the imported strict persistent primitives; finite experiments do not measure native time. Source-level operation accounting above carries the all-length resource claim.

Failed routes retained: minimum-only tail cancellation loses a later disjoint component; eagerly rebuilding the directory on each promotion repeats deep prefix work; committing an old global root after an interruption loses new short coverage; endpoint-event enumeration without paid count aggregation leaves multiplicities unpaid. These are failures of those specific contracts, not native lower bounds.

Independent adversarial review checked the workload coupling, band ownership, strict deque use and sealed-reader deadline. Additional reproducible independent checks cover all 9,216 interval/coverage-pattern combinations in an eight-leaf band, 125 interrupted forks and 875 residual-work comparisons. These are finite semantic evidence, separate from the all-length argument.

Next decisive test: Extend the linear truncated-work criterion beyond one interval per row. Determine whether an input-growing number of occupied-length components admits a checked ordinary-input export and a release bound controlled by query scale, rather than by total component count. Test many short separated components followed by a huge endpoint, with late short-name selection and no supplied decomposition. Independent-store composition remains a separate frontier.

Classification: a proof extension combining imported strict persistent sequences, the maintained ordinary-name busy-period argument and standard Boolean range-cover trees. The added content is the coupled producer, interruption-safe band worker and deadline-safe sealed stream for this checked language. This dependency classification is well supported; external priority has not been established. Root admission and publication rank are unchanged.