Mixed-region budgets with input-paid preparation

10 October 2026. Assessment 201. Written native theorem 66, independently reviewed, with finite evidence recorded below. No root-ledger admission or external priority claim.

Subsequent work: The note Sparse completion certificates supplies a sparse-input preparation mechanism and isolates the still-open composition obligation. The theorem below retains its complete-level and mixed-budget hypotheses.

Statement and payoff

The useful quantity for reuse is the number of mixed dyadic regions, not the number of occupied intervals. A complete-level validator also supplies something less obvious: enough later ordinary input to finish the representation before reuse begins.

Put $I_j=[2^{j-1},2^j-1]$ and $J_\ell=[2^{\ell-1},2^\ell-1]$. For a finite set of occupied positive lengths, let $C_j$ be its canonical aligned Boolean tree in $I_j$. EMPTY and FULL denote uniform regions; BRANCH has two children, and equal constant children collapse. Let $M(C_j)$ count BRANCH coordinate occurrences in the unfolded tree, even when physical records are shared.

Written theorem 66. Fix an integer $r\ge0$. In the ordinary right-first Horn language, require each final right row to satisfy:

1. Every occupied positive length contains all binary words of that length, and length zero is absent.
2. For every index block, its final canonical trees satisfy

$$\sum_{j\in J_\ell}M(C_j)\le r2^{\ell-1}.$$

One fixed deterministic native scaffolding automaton, depending only on $r$, checks these conditions and recognizes the pinned SAT language. It uses bounded work and allocation per actual input symbol, including the final symbol. Row interleaving, duplicate records, ordinary nonempty name lengths, occupied lengths, retained versions and selection populations are unrestricted within the two checked conditions. Intermediate mixed budgets may be exceeded and later repaired.

This extends theorem 65. Its class with at most $s$ one-interval partial bands per index block satisfies the present condition with $r=4s$: an interval in band $j$ has at most $2(j-1)$ mixed coordinates, and $j<2^\ell$. The new class also permits an input-growing number of separated runs inside one band. For example, in band $j\ge2$ choose alternate positions within its first aligned dyadic subregion of size $t=2^{\lfloor\log_2 j\rfloor}$. There are $t/2$ runs, while the mixed count is at most $(j-1-\log_2 t)+(t-1)<2j\le4\,2^{\lfloor\log_2 j\rfloor}$. Other bands may be empty. Thus fixed $r=4$ admits this growing family, which violates theorem 65’s one-interval condition.

The result is a sufficient criterion for checked serial reuse. It does not join independently owned stores, cover arbitrary radial profiles, or transfer entry 129’s state/port bounds to native languages. The PEG consequence is for the reversal of this checked native language.

1. A completion-funded scheduling lemma

Consider one row’s subsequence of actual target words. Discovering a previously absent positive width $n$ releases one job at that word’s delimiter, of cost at most $a(n+1)$ local steps for a fixed implementation constant $a$. No other event releases a job at that width. A work-conserving serial worker receives $4a$ steps on every later target bit of that row. It receives no advance credit and need not run on names or delimiters.

If every occupied level is complete at the right-input boundary, every released width-$n$ job has a later distinct word of length $n$: there are $2^n\ge2$ required words, and the release followed the first one. Choose one such later word as its witness. Witness words for different jobs are distinct, since jobs have distinct widths within a row. Each witness occurs entirely after its job’s release.

Suppose work remained at the boundary. Start with the job release that began the worker’s last uninterrupted busy period. Every job released in that period has its witness later in the same period and before the boundary. The period therefore contains at least $\sum n$ service-bearing symbols for those jobs. Its total released work is at most

$$a\sum(n+1)\le2a\sum n<4a\sum n.$$

While the period remains busy every granted service step is used. This contradicts positive remaining work. If a batch empties the worker and later work arrives, that begins a different busy period; unused steps are discarded. Witness bits never precede their own release, so no current-word or banked credit is hidden in the argument. Interleaving other rows does not affect the argument on each row’s subsequence.

Consequently all row workers are empty at every all-complete right boundary. A first occurrence at a positive width cannot complete its level. On a word that finally completes a level, its target bits have already supplied service before its delimiter changes the completeness gate. Thus the argument requires no final-delimiter drain. An incomplete input can be rejected using the maintained incomplete-level flag, without draining its workers. This lemma concerns mandatory literal validation input, not inserted padding or an externally supplied promise.

2. Serial producer and current-version ownership

Retain the ordinary-name dictionary, target/width dictionary, exact distinct-word complete-level gate, unary word rulers and bounded-local length counter from the maintained producer. They identify the first occurrence of each width immediately. Reject an empty right target by a finite flag. The dictionary prepares its ordinary name route while that name is read.

Each row header has separate foreground and worker components. The foreground component owns the immediate literal/width validator. The worker component owns a strict persistent FIFO of width jobs, its committed band and block directories, and at most one active insertion. A first-width delimiter enqueues the just-built unary length root and its prepared numeral. It does not repair a tree, copy a return path or decrement an unbounded mixed counter there.

While that row’s later target bits arrive, service the worker’s fixed batch. The current row header remains accessible after its ordinary name has been routed. A word delimiter installs the current foreground fields and the current worker fields into that same header using the inherited input-funded dictionary capsule. Completion never installs a row header captured at an earlier word. The global validation counters are separate current roots, not fields captured in a delayed tree job.

Only this serial worker changes the row’s canonical band trees. A job takes the then-current committed directory when it starts; later width arrivals only append to its FIFO. Thus it needs neither speculative roots for every possible stopping length nor a rebase against unrelated point updates. Retained versions preserve their own immutable foreground fields, queues, continuations and directories.

The strict deque/FIFO operations and simultaneous-record compiler are the same imported, charged primitives used in theorem 64. No random access, measured split, callback comparison, lazy evaluation or address equality is added.

3. An explicit local point job

For width $n$ let $j$ be its binary numeral length. These are proof variables, not integer machine labels. The job performs the following phases through bounded frames.

Prepare the route. Traverse the retained length ruler if necessary to reproduce the inherited length counter and numeral; this costs at most a fixed multiple of $n+1$ steps. Alternatively use the numeral already prepared during the word. Convert or reverse its linked digits as necessary, one digit per step, to expose most-significant-first order; discard the leading one, and retain the remaining route and a unary height root. There are $j-1$ route digits. This deliberately permits the conservative linear producer bound; logarithmic producer preparation is unnecessary for the theorem.

Focus the directories. Walk the row’s dense band deque from band 1 to band $j$, moving each passed record from a remaining suffix to a finished prefix. Create missing EMPTY records, one per step. A unary route-length ruler stops the walk; a local index counter and its power-of-two flag detect starts of index blocks. In parallel focus the block deque, advancing it only at those events. Existing suffixes are retained, not copied.

Build a fresh unary capacity root with $r$ units per visited band index. At the start $B=2^{\ell-1}$ of a new block, this root has exactly $rB$ units and initializes that block’s slack. Fixed $r$ units per step and at most $j$ visited indices pay the preparation. Existing block records retain their own current slack/debt roots. Empty intermediate blocks have zero mixed population. No capacity of input-dependent size is made at a delimiter.

Insert one point. Descend the canonical tree using the route, saving a frame with the old node label, other child and direction at each step. EMPTY has two virtual EMPTY children. At the selected leaf return FULL. On each return retain the changed child and old sibling, collapse equal uniform children, or allocate one BRANCH. Every action uses fixed labels and bounded field observations. The path has $j-1$ frames. A previously FULL subtree can shortcut; in the first-width application its leaf was absent, but the operation remains correct with duplicates.

For every visited coordinate compare the old and new root labels. Its change in mixed population is

$$\delta=\mathbf 1_{\text{new BRANCH}}-\mathbf 1_{\text{old BRANCH}}\in\{-1,0,1\}.$$

Unvisited sibling coordinates are unchanged. Summing these frame changes therefore gives the exact change in unfolded mixed count. A last missing leaf can collapse many ancestors, but each collapse and its budget adjustment is a separately serviced return step. No physical-record deduplication enters this count.

Commit. Replace the focused band and block records and restore each directory with an end update and strict catenation of its current prefix and suffix. Clear the active frame and take the next FIFO job if present. A fixed number of fields and sequence operations suffice. All directory movement, capacities, route conversion, traversal, return work, counter adjustments, allocation and commit fit a bound $a_r(n+1)$ for one fixed implementation constant $a_r$. Fix $a_r\ge1$ once for these primitives and run $4a_r$ steps per actual target bit. The bound does not depend on the final row’s mixed budget, so temporarily complicated rows are also prepared correctly.

4. Check the final mixed budget locally

A block with capacity $rB$ stores signed slack $rB-\sum M(C_j)$ as two unary stacks: credit and debt, with at least one empty. Initially credit is the prepared capacity and debt is empty. A mixed-coordinate increase pops credit when possible, otherwise pushes debt. A decrease pops debt when possible, otherwise pushes credit. Each unit adjustment has bounded cost. Debt is nonempty exactly when the budget is exceeded, including when $r=0$.

Maintain a global unary counter of blocks with nonempty debt. Only a zero/nonzero debt crossing changes it, by one unit. During a point job the active block’s updated slack/debt is authoritative; its older committed directory entry is a suspended snapshot. The active state records its current violation flag. Each return step adjusts the current global counter, and commit transfers the authoritative block state into the directory without counting it again. Other rows can be serviced between words; their active overrides have the same interpretation. No global root captured at job start is ever restored.

At the right boundary, first apply the immediate complete-level gate. If it passes, the scheduling lemma proves every active override and queue is already finished. The global bad-block counter then refers exactly to the committed canonical final rows. Its zero test is equivalent to the theorem’s second condition. There is no boundary scan or cleanup. A defensive queue-nonempty flag could also be maintained, but it is not needed as an additional language restriction.

This separates two certificates. Complete levels ensure that all literal words are present and that producer debt has been paid. The mixed gate controls future reuse cost. Neither certificate is inferred from a compact storage size.

5. Charge all pending reuse work

For $k\ge1$ put $L=\lfloor\log_2 k\rfloor+1$. The final checked budget gives

$$\sum_{j\le k} M(C_j)\le r\sum_{\ell\le L}2^{\ell-1}=r(2^L-1)\le2rk.$$

The dense directory additionally costs at most a fixed multiple of $k$ visits. Its end is a local certificate that all later bands are EMPTY. Each row selection releases one cursor, not one separately credited job per mixed component.

At a destination band, perform the aligned union of review 200. EMPTY incoming coverage does nothing; FULL incoming or FULL destination returns FULL; EMPTY destination shares the incoming tree. Only two BRANCH roots recurse. A fixed-size explicit stack implements calls and returns, including canonical collapse. There are at most $1+2M(C_j)$ calls for a row’s band.

The important bound concerns residual work. Hold an already active band insertion fixed until it finishes, then compare the same old waiting sequence with and without the new row’s tree $C_j$. An extra old-job expansion requires baseline coverage EMPTY and augmented coverage mixed at that coordinate. It is therefore a mixed coordinate of $C_j$. After that old job commits, baseline coverage there is nonempty forever, so no later old job can charge the coordinate again. Across all waiting jobs there are at most $M(C_j)$ extra expansions. This is the one-time coupling argument of review 200, now applied to a paid producer.

Normalize every recursive call and return to a common fixed local-step allowance, including shortcuts. Then call-count additions give actual additive service-work bounds. Existing jobs keep their relative order; inserting the new row can interleave it among them, but the same argument applies to the suffix after its insertion at that band. Higher-band active operations retain their frozen bases during lower-band interruptions. New releases restore the current finished-prefix and pending deques, never an old global root.

For some fixed constant $b$ covering frames, promotions, directory operations and renewed prefix passes, a release increases truncated remaining work by at most

$$b\sum_{j\le k}(1+M(C_j))+bk\le b(2r+2)k.$$

Set $c_r=b(2r+2)$, rounded upward to an integer. These are fixed implementation constants, not numbers computed from the input. The incoming merge and its effect on all old jobs are both included. A service step decreases positive truncated work by one, because the worker always finishes smaller bands before advancing.

The other premises of the charged band criterion are unchanged: ordered sealing, local EMPTY-tail termination, immutable versions, and a $16\,2^{k-1}$-step conceptual leaf enumerator for band $k$. Thus $64c_r$ service steps per actual selection-name bit, $1024c_r$ per query bit and 1024 reader steps per query bit suffice. The inherited distinct-name busy-period bound seals band $k\ge4$ by query position $2^{k-4}$; the reader emits every needed Boolean before its query-prefix deadline. The first batch handles the first 15 positions. Both positive and negative answers, empty targets and the final SAT complement follow exactly as in theorem 64. No new releases occur inside a query fork.

6. Native resources and the structural lesson

Fix the counter, dictionary, strict sequence and simultaneous-record implementations. All foreground and worker records have bounded degree, finite labels/control and fixed-radius observations. A transition uses old roots or a bounded same-batch record construction. Initialization consists of empty roots and finite flags. Producer work, old-storage observations, route reconstruction, discarded capacity roots, queues, return frames, global gates, selected-row access, pending merges, enumeration, retained snapshots and final output are all charged to actual symbols.

For actual encoded length $N$, logical work and storage are $O_r(N)$. The inherited compiler packs the fixed logical batch into $N+1$ physical scaffold nodes, with $O_r(N\log(N+2))$ explicit pointer bits. This is one fixed automaton for fixed $r$, with strict per-symbol and final-symbol deadlines. No supplied decomposition, ready external handle, padding, advice, free preparation, pointer-identity test, metadata or timing channel, or EOF service is used.

The mechanism combines mandatory future validation work with an immutable serial producer, then bounds each selection’s disturbance of pending work by mixed coordinates. It explains why branching plus local negative observations can preserve useful reuse without fitting a matching-only summary. It does not assert a universal characterization. Replay still pays every fork; affine-fragment joins, persistent causal sharing and unary coherent controls supply neither this input-funded producer nor independent-store access. Entry 129’s established full-relation quotient and growing-alphabet state/port bounds keep their exact hypotheses.

7. Failed route, evidence and next test

Preparing a finished canonical root for every possible stopping length is unnecessary here. It can also be too expensive without prior preparation. For a precise family, choose $s\ge4$, $h=2^{2s}$ and a band of width $W=2^h$. Partition it into $h$ coarse dyadic cells, grouped into $2^s$ cells per group. In the first half of each group, place its distinct $s$-bit identifier plus fixed 0 and 1 markers as full/empty cells; leave the second half empty. The baseline has at most $h-1$ mixed coordinates. Adding any one fine point in an empty second half creates at most $h$ further mixed coordinates.

Across all $W/2$ such points, consider their updated ancestor subtrees at group scale and every larger scale. There are $s+1$ scales. At a fixed scale, unchanged identifiers distinguish different regions and the inserted point distinguishes positions within a region. The isolated fine point gives a full-height branch path, so records from different scales differ in physical height. Hence all candidate outputs require at least $K=(W/2)(s+1)$ distinct immutable BRANCH records. If $P$ were prepared earlier, at least $K-P$ must be newly allocated. This is an $\Omega(W\log h)$ all-candidate requirement inside the exact checked mixed-budget class: the sole band index is $j=h+1$, its index block starts at $h$, and $r=2$ covers all these profiles. It is not a native impossibility theorem. Earlier complete-level input could pay $P$. The serial producer avoids asking for those candidate outputs at all.

The primary executable audit checks explicit return-frame point insertion, signed block counters, repaired violations, immutable retained trees and the release/witness schedule. The independent audit is separately designed. The existing mixed-coupling audit and sealed-band audit test the reused consumer obligations. Finite models use integers, tuples and direct sets as semantic oracles; they do not claim Python execution is a native implementation. The proofs above supply the all-length and native resource assertions. Assessment 201 records exact results and independent review.

Next test at assessment 201: replace complete-level input by sparse literal rows while retaining a paid mixed-region export. Identify a locally checked future-input certificate sufficient to finish first-width jobs, or prove that the existing producer contract fails when a row ends with its first occurrence of a large width. Compare the existing content-sensitive mixed-prefix controls in reader sections 32, 33, 34 before selecting a sparse-row extension: length-invariant enumeration alone cannot recognize arbitrary sparse word sets, and an already solved bounded-width control must not be presented as a new result. Unrestricted radial profiles and independent-store joins remain separate frontiers.

Classification: a written proof extension using the imported strict persistent primitives, the established native validation/dictionary machinery, review 200’s written one-time coupling, and theorem 64’s charged scheduling criterion. It closes the ordinary-input producer obligation for the stated mixed-budget class. It makes no external novelty claim, root admission or unrestricted SAT/scaffold separation.