Deadline-safe reuse with missing levels

10 October 2026. Assessments 182–189. Written native constructions, with finite semantic and scheduling audits. No root-ledger admission or novelty claim.

Result and payoff

Continuation: Name-dominated suffix reuse now handles initial missing intervals under a checked name/minimum inequality. Unrestricted intervals remain open.

Latest completed bounded-point construction: section 17 removes the maximum-diversity bound for any fixed number of missing levels per row. Section 18 tests arbitrarily long missing intervals and isolates a restricted FIFO readout failure; a native interval consumer remains open.

The fixed residue restriction can be removed for any fixed number of final binary balls. The useful mechanism is a readable unfinished computation: ordinary selected names pay for incremental radius comparisons, and the current ball answers short queries while a longer query pays off the remaining comparison work.

Written theorem. In the ordinary right-first Horn encoding of section 12.1, restrict each nonempty final right row to a complete binary ball

$$B_L=\bigcup_{j=1}^{L}\{0,1\}^j,$$

with at most K distinct final radii, for any fixed positive integer K. One fixed deterministic native scaffolding automaton (depending on K) checks these conditions and recognizes SAT, with bounded work and allocation on every actual input symbol, including the last. Distinct radii may have the same residue under any fixed modulus. Sections 1–5 first prove the two-radius case; section 7 carries the dependent extension to every fixed K. Target order, row interleaving, intermediate diversity, ordinary name lengths, duplicate records and left fanout are unrestricted.

All preparation, retained versions, name routing, pending work and query repair are charged to actual encoded length N. The construction is serial right-first reuse, not a free join of arbitrary independently stored versions. Its PEG consequence concerns the reversal of this checked language. General radial profiles and unrestricted SAT remain open.

Reading the constructions and their checks

A row contains complete levels of binary words, possibly with missing levels. The proof separates preparing a row from combining selected rows. Preparation must expose usable roots; reuse must answer even while some comparisons remain unfinished.

The gap checker imports the bounded-exception receipt and single-hole numeral helpers; the latter also imports the ball receipt checker. The linked source pages provide line anchors and exact downloads. Their Python containers are semantic test machinery, not a claim that those containers implement bounded native operations. The queue proof comparison identifies the scheduling contract used by the written construction.

1. Right preparation and a cheap incremental comparator

Use the input-dominated maximum histogram and literal ball gate, dropping the residue gate and requiring only D at most two. That construction checks complete levels, absence of holes and the number of occupied final maxima without a final scan.

Each row additionally retains the binary numeral of its maximum radius. Construct a fresh target-length counter by incrementing once per actual target bit, starting at zero. Use the immutable maximal-run counter of section 35.2, without its optional capacity cap. Its carry operation examines only a bounded number of run records and allocates boundedly many records. At a maximum-changing target’s delimiter, retain this ready numeral alongside the already prepared unary ruler. Otherwise discard it. No binary numeral is constructed after its target ends.

Compare two positive radii by reading their canonical numerals least-significant bit first. A run cursor pops one unit from its run-length stack per bit and advances to the next run when empty. Remember the last unequal bit pair in finite control. If one numeral ends first, it is smaller; if they end together, the last unequal pair determines order, or they are equal. There are no high zero bits. This is an exact incremental comparison, not a unit-cost integer operation.

For a fixed implementation constant a, including cursor initialization, FIFO handling and completion, every comparison involving a radius at most M finishes within

$$C(M)=a(1+\lceil\log_2(M+1)\rceil)$$

elementary bounded local steps. It stops when the shorter numeral ends, even if the other radius is arbitrarily larger. Each suspended comparator has only a fixed number of roots and finite control fields. Radius equality is established from bits, never from pointer identity.

2. An exact source receipt with unfinished work

Freeze the checked right dictionary. A left source u stores a persistent receipt consisting of:

• a trie of already selected ordinary intermediate names;
• an optional candidate row, including its numeral and unary radius ruler;
• a strict persistent FIFO of comparison jobs and at most one active comparator;
• a finite flag saying that two unequal selected radii have been observed.

During u, open its outer serial capsule. During the following v, traverse both the source’s selected-name trie and the frozen right dictionary. Also execute q elementary worker steps per actual v bit, for a fixed q at least 4a. Service occurs before this record’s job is released. This order deliberately allows no borrowing of unavailable work from earlier input.

At the delimiter, ignore a duplicate or missing right row. For a first nonempty selection, install its root immediately as candidate. For another newly selected name, enqueue its ready row descriptor. The job compares that row with the candidate. Equality discards the job. On inequality retain the larger row, mark the receipt settled, and discard the rest of the FIFO by dropping its root. All later selections can then be ignored semantically: two distinct selected radii exhaust the checked global two-radius universe, so their larger value is the maximum of every possible selected set. The ordinary syntax still must be read.

Before settlement every completed comparison was equal. The candidate therefore never changes. The queue represents exactly the unprocessed distinct selected names. This invariant makes suspension between arbitrarily interleaved sources harmless. A delimiter commits the selected-name capsule, queue roots and comparator state in bounded work; it does not finish the queue. Empty sources denote the empty union.

This is the stronger readout operation that replaces an immediate final class label. An unfinished receipt has an exact meaning and a query algorithm, rather than an uncharged promise of later repair.

3. Distinct ordinary names bound the unfinished work

Fix an unsettled receipt at the end of left input, with candidate radius M. Every earlier comparison in this receipt involved that same M, so each costs at most C=C(M). Every enqueued job has a distinct nonempty binary name. Let W be the work required to finish the current job and all queued jobs if comparisons continue to be equal; stop earlier if an inequality settles the receipt.

The work-conserving service schedule gives

$$W\le F(M):=C+\sum_{d\ge1}2^d(C-qd)_+.$$

To prove this, take the final busy period. Its first released job receives no credit for its own preceding name and contributes at most C. Every subsequent release has received q steps of service per bit of its name while that busy period remains nonempty. Duplicate and missing-row records only add service. Bound the resulting deficit by replacing each negative summand with zero. There are at most 2^d distinct binary names of length d. The same argument applies to an active partially completed job; already executed steps only reduce W. If a comparison would be unequal, this bound pays for its prefix through settlement and need not pay for discarded jobs.

The sum is finite. Since q is at least 4a,

$$F(M)\le C\bigl(1+2^{C/q+1}\bigr)\le 32aM=:BM\qquad(M\ge1).$$

For the last inequality, use C at most a(2+log_2(M+1)), log_2(M+1) at most 2 sqrt(M), and M+1 at most 2M. These bounds give less than 18a M^(3/4), hence the displayed conservative constant. The machine does not compute M, C, F or a logarithm. They certify a fixed service schedule.

This estimate depends on actual ordinary-name spelling and exact deduplication. Releasing another expensive job for every duplicate one-bit name destroys it. A long source name is not needed as extra credit, and no prefix-free assumption is made about the intermediate names.

4. Query service and promotion repair meet the last-symbol deadline

The positive source pin retrieves its receipt through the existing serial dictionary. The negative target pin supplies an ordinary nonempty binary word b. Ball membership depends only on its length, but the parser still consumes and validates every literal bit.

An empty receipt answers false for relation membership. A settled receipt follows its maximum’s unary ruler, popping one unit per target bit and remembering exhaustion. An unsettled receipt starts the same reader for its candidate radius M and, in a separate fixed lane, executes r=4B worker steps per target bit. It also builds a unary stack recording the number of target bits already seen. The early answer is available whenever the original M-ruler has not been exceeded: every selected union contains B_M.

By target bit t=ceil(M/4), the worker has either finished all equal jobs or found an unequal pair, because rt is at least BM. If all jobs were equal, the original ruler is the exact answer. If the candidate remains the larger radius on inequality, it is now known maximal and its existing reader is exact. Only when the newly found radius H is larger is a repair needed.

For that sole promotion, start a cursor at the retained H-ruler and capture the current target-length stack as a replay debt. Pop up to four debt units and H-ruler cells immediately in that same target-symbol batch. On each later target bit, while debt remains, push one debt unit and pop up to four units and ruler cells. Once debt is empty, the H cursor is aligned with the target prefix and follows one cell per future bit. The old M reader remains available throughout. Ruler exhaustion during repair is recorded as a permanent overflow flag.

There is at most one promotion, since an unequal pair settles the receipt. If promotion occurs at t no later than ceil(M/4), alignment completes by

$$t+\left\lceil\frac{(t-4)_+}{3}\right\rceil\le M.$$

For M from 1 through 4 the first query bit performs promotion and its one-unit repair immediately. For M at least 5, use t at most (M+3)/4; the displayed bound follows directly. Thus repair finishes before any target prefix beyond M needs the larger ball. A query ending earlier is already known to belong to B_M; a query ending later has the exact aligned maximum reader. Output is ready on its final delimiter, with no EOF drain, and with no need to know the eventual query length in advance.

All replayed units were allocated from the actual target prefix. Reading them again is explicitly charged to the fixed repair lane; the prefix is not available through free numerical indexing. Its order is irrelevant because this is a unary length test, not a replay of a branching word computation.

5. Native resources, scope and controls

The fixed foreground lanes are the inherited literal parser, serial selected-name and outer-source capsules, frozen right lookup, strict FIFO, run-cursor comparator, ordinary unary reader, worker service and repair lane. Their roots and local record fields have fixed arity. q and r are machine constants, not input parameters. All new records refer only to permitted bounded old neighborhoods or the fixed current allocation batch. Applying the existing simultaneous-record compiler gives fixed degree, fixed observation radius, finite labels/control and old-top semantics.

Initialization uses empty dictionaries, queues, stacks and finite control. At most a fixed number of logical records is allocated per actual symbol, including punctuation; retained abandoned jobs, discarded counters, old source versions and replay debt are included. Storage is O(N) logical records, N+1 physical scaffold nodes and O(N log(N+2)) bits for explicit pointer serialization. Invalid right structure rejects at its existing checked boundary. No decomposition, final palette, ready external handle, advice, padding, address comparison, metadata or timing channel is supplied.

The construction permits radii L and L+m for every fixed modulus m, closing the selector gap of theorem 52 first for two balls and, by section 7, for every fixed K. It also permits arbitrarily many intermediate maximum classes, retaining that theorem’s separation from bounded-live profile methods. It uses the persistent FIFO and counters as existing primitives with written bounded local implementations, not as new imported theorems. It is a written adaptation and scheduling argument, not a novelty claim.

The decisive structural combination is: nested predicates, an incremental comparison costing logarithmic time in the smaller radius, deduplicated ordinary names, and a query prefix whose existing candidate remains correct while the worker catches up. The argument does not identify information size with access cost. General radial profiles need not be nested; their OR cannot be replaced by one maximum ruler, so this proof does not close their frontier. Nor does it implement a free join between separately prepared storage graphs.

Two failed routes remain useful controls. Immediate complete comparison after a short v can miss its delimiter. Unconditionally replaying every selected row on the final pin can grow with fanout. Here the pending state is maintained during left input, distinct names limit unpaid comparison debt, and exactly one possible query promotion is repaired before its first relevant observation.

6. Evidence and next decisive target

The finite checker compares an immutable event-level worker with direct maxima, checks the name-deficit formula, exercises duplicate suppression and source suspension, and checks query promotion, prefix repair and retained receipts. Python integers, tuples and maps are semantic oracles; neither their running time nor their allocation is a native compiler replay. The all-length timing proof is sections 1–5.

The fixed-K extension is completed below rather than left as a separate task. Next: test two arbitrary radial profiles with crossing occupied levels. Identify a substitute for the ball prefix that safely answers while comparison remains unfinished, or construct a precise deadline witness for this pending-reader architecture. Preserve the independent-store join boundary.

7. Carry the construction through every fixed final K

The two-radius stopping rule is convenient but unnecessary. For fixed K, the right boundary checks D at most K. In a source receipt, process every distinct selected row: compare with the current maximum candidate, discard an equal or smaller row, and replace the candidate on a strict increase. Do not discard the remaining queue on inequality. This is ordinary maximum aggregation, executed incrementally with the same literal-name deduplication and service rate q. The candidate increases at most K-1 times over the whole lifetime of any source receipt.

The sharper timing fact is measured from the beginning of the query, not separately from each promotion:

Threshold service claim. If M is at least the candidate radius at query start, then within F(M) query worker steps either the queue is exhausted or a candidate larger than M has been found.

For proof, inflate the cost of every job in the left history and in the query prefix through that first event to C(M). Before the event every comparison has a candidate at most M, so the inflation is legitimate. The work-conserving FIFO with these inflated costs has at most F(M) work left at the query boundary, by the same last-busy-period calculation. It dominates the actual unfinished prefix: it never completes a job earlier than the actual worker. Hence the actual prefix through the event fits that remaining budget. One may give all later queued jobs artificial cost C(M), because their execution after the first event is irrelevant to the claim. Initial-candidate installation is a fixed delimiter operation, not an uncharged comparison job.

Consequently a strict promotion from radius M to a larger radius is discovered by query bit ceil(M/4). If M is the final selected maximum, queue exhaustion occurs by ceil(M/4). These are absolute query deadlines even when several earlier promotions have occurred. Comparing huge newly encountered radii does not invalidate a prior deadline: the relevant comparison stops when the smaller, still-current numeral ends.

Allocate K reader lanes in fixed finite control. At query start, lane zero follows the current candidate’s ruler. Every strict promotion starts one additional lane with its new ruler and a captured copy of the current query-length stack. Each new lane independently performs the four-step catch-up from section 4 while the original lanes continue. There are at most K-1 new lanes. Do not cancel or reset an older lane when another promotion occurs.

A lane introduced by promotion from M aligns by target position M. Its predecessor lane has already aligned by the preceding, no larger candidate radius (or was lane zero), so the predecessor covers all target prefixes up to M while the new lane catches up. Induction along the promotions shows that at every target prefix belonging to the selected union, at least one aligned lane reports membership. Conversely every aligned lane denotes an actually selected ball, so none gives a false positive. If the query ends beyond the final maximum, its worker queue and all necessary readers have already caught up; every aligned lane reports overflow, and no pending lane can hide a larger answer. Return the OR of the K aligned, nonoverflow flags. No final search or radius comparison is required.

The prefix stack grows once per actual query bit. Each lane captures a root and maintains its own immutable repair debt; sharing the prefix does not spend work twice for free, because a separate fixed four-step service allowance is reserved for each of the K lanes. Total per-symbol work, roots and allocation depend only on K. Query-specific lanes are transient new records; the frozen source receipt and all earlier source versions remain intact. The same receipt can be queried again from its original state without shared mutation.

This proves the stated fixed-K native theorem with O_K(N) retained logical records and the same orientation and side-channel restrictions. It is not the same as allowing unbounded K: then the number of simultaneous reader lanes and the compiler constants would grow with the input. The useful criterion is now explicit: a monotonically improving representative, logarithmic comparison against the smaller radius, distinct-name service, and a bounded number of promotions whose replacement readers catch up inside the predecessor’s valid prefix.

8. Why the same schedule does not yet handle crossing profiles

The precise next obstruction is the ratio between comparison work and the prefix already answered by a retained reader. Distinct-name charging transforms a job cost C into a possible deficit of order C times 2^(C/q). For balls the comparator costs logarithmic work in M while the old reader certifies the first M target lengths. A sufficiently large fixed q makes that deficit fit inside the certified prefix.

For two arbitrary radial rows, a literal comparison of width-membership streams can take d steps before the first difference at width d. Applying the same name argument gives an exponential upper bound in d, not a linear query window. This failure of the proposed budget is not a lower bound: it neither proves such backlog unavoidable in every representation nor rules out preprocessing, shared prefix summaries or a different exact pending interpretation.

Also, a radial row with holes does not supply the ball’s continuous positive prefix. A large last occupied width gives no answer for a missing early level. Replacing the ruler by the last width alone is therefore semantically invalid. The next useful test is an exact, paid comparison or prefix summary tied to the first relevant query difference, including two rows whose occupied levels cross. The prior general class-correction worker remains an alternative; this result does not silently discharge it.

9. Crossing profiles: an observation-cover obstruction

Assessment 183, 10 October 2026. This section records a failed extension and a restricted representation bound, not another native-language theorem. The fixed-K ball theorem above is unchanged.

A common answer prefix alone does not make the pending reader work. The following pair has an arbitrarily long common positive prefix and only two final profiles, yet separately copied streams can require repeated traversal of that prefix. The obstruction survives adaptive scheduling, negative observations, and knowledge of the global profile multiset.

9.1 The exact exported interface

A radial profile P denotes all binary words whose positive lengths belong to P. An exported row has one opaque root leading to a private unary chain: cell j holds its width-j membership bit. All chains have the same length and topology. Names route to roots through the ordinary dictionary. There are no jumps, cross-row edges, cached class labels, or data-dependent descriptor fields. Root addresses, allocation order, timing, producer control and pointer identity are not observations. Fixed-radius access to these chains is charged as a bounded number of elementary cell advances. New records and cached observations are permitted and charged; they cannot reveal an unvisited cell.

This is an interface restriction. In particular, the producer’s knowledge of the input is not silently retained in its control or auxiliary storage. Any retained classification, shortcut or shared predicate would be a stronger interface. The lower bound below does not assert that a native producer must export this restricted interface.

Let P0 be the number of charged cell advances performed after export but before the left selection starts. Include their resulting caches and cursor positions. Let H be the complete number of subsequent actual input symbols through the output delimiter, including ordinary names, pins and punctuation. A consumer making at most c elementary advances per symbol has total inspection budget P0+cH. Any dictionary routing, allocation and output costs are additional; granting the consumer immediate access to every root after its name has been read only strengthens the lower-bound model. This grant is not an upper-bound construction or free native routing claim.

9.2 Same palette, same populations, opposite answer

Fix D at least 2 and define

$$A_D=\{1,\ldots,D-1\}\cup\{D+1,D+2\},\qquad B_D=\{1,\ldots,D\}\cup\{D+2\}.$$

They agree below D, cross at D and D+1, and have the same minimum, maximum and number of occupied levels. Both profiles are valid finite radial rows. Their numbers of literal target words differ, but the construction preserves the entire global multiset, so it also preserves total literal input length.

Use n pairs of distinct ordinary names (x_i,y_i), all with common length ell=ceil(log_2(2n)). In the baseline, x_i names A_D and y_i names B_D. Select precisely all x_i into one left source. For alternative i, exchange the profiles of x_i and y_i. Every instance has exactly the same two-profile palette and n rows of each type. Names, chain topology, chain lengths and selection records are identical. The full right relation has the same number of records and encoded symbols because all row names have the same length. The two representative profiles and their global populations may even be disclosed to the consumer; their assignment to ordinary names is the unresolved information.

Query the selected union at the literal word 0^D. The baseline answers false, while every one-pair alternative answers true. The corresponding positive-source/negative-target Horn pins reverse these membership answers into SAT answers. No claim of a native reduction follows from this semantic observation alone.

9.3 Inspection-cover inequality

Restricted observation bound. Every deterministic consumer correct on this family must, on the baseline, spend at least nD elementary cell advances after export, including preparation. Consequently

$$P_0+cH\ge nD.$$

Run the consumer on the baseline. For each pair i, it must reach width D in at least one of its two private chains. Otherwise swap that pair. Every label, null test and bounded local observation actually made remains unchanged: all visited cells in those two chains precede D, and every other chain is identical. By induction, the same input and observation transcript induce the same allocations, cached data, control branches and final answer. That contradicts the different correct query answer.

Reaching width D in one private chain requires D elementary advances from its root. Distinct pairs share no such edges. Summing the n necessary crossings proves the inequality. Arbitrary interleaving, restarting, prioritization and caching do not weaken it. Negative local observations are already part of the indistinguishable transcript. If a concrete local model reads several cells in one transition, absorb that fixed factor into c.

For one fixed source spelling and fixed syntax there is a constant b such that H is at most D+b n(ell+1)+b. If P0 is bounded independently of D, choose n>c and then choose D so that

$$(n-c)D>P_0+cbn(\ell+1)+cb.$$

The consumer misses the deadline. More generally, the same inequality states exactly how much prior inspection must have survived export. There is no assumption that preparation is intrinsically small: P0 of order nD can cover this witness.

This is stronger than a FIFO failure, but narrower than a native persistent-language lower bound. Literal complete levels can supply exponentially many right-input symbols in D, ample total time to perform nD work. The issue is whether useful results survive in an immediately name-accessible interface and remain current under arbitrary right-row updates. Total preparation time alone does not answer that question.

9.4 Why the attempted repairs fail, and what escapes

Changing FIFO to round-robin or prioritizing the newest selected row cannot defeat the inspection cover. Keeping more copied cursors merely distributes the same n crossings. Deduplicating names does not identify equal rows: all selected names here are different. Global minimum, maximum, palette size, occupied-level count and profile populations also do not identify which x_i contributes the missing level. Thus even a long positive agreement prefix does not suffice; the problem is repeated access to the separating observation, not specifically the presence of early negative answers.

There is also a direct FIFO deficit witness. After a known A_D candidate, release n distinct comparison jobs of cost at least D, with q ell worker steps before each release. Even granting that service in full, the remaining work after the final release is at least nD-(n-1)q ell. Put the only selected B_D last. For fixed q and query rate, sufficiently large n and then D prevent its distinguishing bit from being read by query length D. This calculation is a specialization of the inspection obstruction, not a lower bound on all comparators.

A stronger export escapes immediately: retain two representative readers and a locally readable class bit at each row’s name terminal. During each selected name, route normally and OR its bit into a two-bit source mask. During the query, run the selected representative readers in two fixed lanes and OR their answers. Arbitrary crossing and negative observations then cause no difficulty. Initialization, dictionary routing and representative construction still have to be paid; this is the existing finite-selector mechanism as a conditional transfer, not a new checked native theorem. In the copied-stream model, constructing all required assignment certificates must itself cross an inspection cover; an ordinary-input producer may have learned them earlier and exported the work.

The decisive next test is therefore a paid export operation: maintain a shared separator or classification predicate during right construction, including a last-record change of the separating level, so that a later short ordinary name can select the correct representative without copying or traversing every alias. A retained predicate may bypass explicit class bits, but its observation and update costs must be specified. The restart-free completion-debt worker remains an alternative. Independent-store joins remain separate.

9.5 Evidence and admission boundary

The observation-cover checker exhaustively compares baseline and swapped-chain prefix transcripts in small instances, checks the minimum covering cost against nD, verifies the unchanged global profile multiset, and checks the prepared-class-mask escape on every selected class assignment in its finite range. It also exhibits charged ordinary-name deadline inequalities and FIFO backlogs. These are finite checks of the written argument, not an enumeration of native machines.

Entry129’s imported matching and positive-path results are unchanged and are not used to promote this interface bound. The new material is an elementary written adversary, a failed copied-stream extension, a finite experiment and a conditional selector control. The obstruction adds no separate root claim, major mathematical-result count or novelty claim.

10. Carry the escape through: bounded end defects are native

The obstruction has a constructive consequence. A finite window at the current maximum can export the relevant classification during right construction. It need not wait for a final profile scan or relabel other rows.

Written native extension. Fix nonnegative b and positive K. In the same ordinary right-first Horn language, require every nonempty final right row to have a maximum H and to contain every binary word of every positive length at most H, except possibly whole levels at lengths H-b through H-1. Nonpositive lengths are ignored. Require at most K distinct final maxima. One fixed deterministic native scaffolding automaton checks this structural condition and recognizes SAT with bounded work and allocation per actual symbol, including the last. Right order, row interleaving, intermediate diversity, ordinary name lengths, duplicates and left fanout are unrestricted.

For b=2 and a common maximum H=D+2, this includes both crossing profiles A_D and B_D from section 9. It thus escapes that obstruction through a charged richer export. More generally there can be up to K times 2^b different final profiles. The theorem is a finite-defect extension of the ball construction, not a solution for arbitrary two radial profiles: a missing level may not drift unboundedly far below its row’s maximum. It still concerns serial right-first reuse, not arbitrary independent-store joins; the PEG consequence is for reversal.

10.1 An exact gap counter and a finite moving window

Each row keeps the literal and unary-width dictionaries, maximum ruler and numeral from sections 1 and the preceding maximum-histogram construction. Add a unit stack g of size

$$g=H-|\{j:\text{width }j\text{ is occupied in this row}\}|.$$

This is the number of absent positive levels at or below H, regardless of whether occupied levels are complete. It is nonnegative. Initially H=g=0. During a new actual target of length n, copy the old g root into a temporary working root and consume the old H-ruler. Each bit strictly beyond H pushes one gap unit. At the delimiter, if width n was previously unoccupied, pop one gap unit. Thus the new value is

$$g'=g+(n-H)_+-\mathbf 1_{\{n\text{ previously unoccupied}\}}.$$

Every pop is legal: a newly occupied width either fills an old hole or is among the newly exposed levels. The possibly large increase is spread over the actual excess bits of the target. There is no large arithmetic operation at its delimiter. Duplicates and further words at an occupied width do not change g.

Also retain b occupancy bits for the levels immediately preceding the current maximum. Treat nonpositive levels as occupied padding, so they never count as holes. During the unary-width descent driven by each target, keep a finite sliding window of the last b predecessor-occupancy bits. If this target establishes a new maximum n, its delimiter installs that window as the new row mask. The maximum itself is occupied by the new word. Missing dictionary tails supply zero occupancy, and the initial window uses occupied padding.

If n does not increase H, inspect the remaining old H-ruler at the delimiter through b+1 fixed cells. This determines whether H-n is one of 1,…,b. On first occupation of such a width, set its corresponding mask bit. Otherwise leave the mask unchanged. The equality case n=H needs no mask change. This handles short updates to a large row without routing to H: only the already advanced ruler’s bounded remainder is inspected.

Let t be the number of zero bits in this finite mask. A row has no missing levels outside the permitted window exactly when g=t. Test that equality by inspecting at most b+1 cells of the unit stack. Track a global unit stack of rows failing this condition, changing it once at each row delimiter according to the old and new finite bad flags. A new row has no old contribution. Intermediate bad rows are allowed.

Keep the existing global incomplete-level count I, maintained by exact literal-pair deduplication and capacity counters, and the current maximum histogram. At the right boundary require I=0, no bad rows, and at most K occupied maximum classes. These local tests are equivalent to the stated final structural condition. No row scan, decomposition, supplied palette or finish-time classification is used. The row also retains H modulo b+1, computed on the actual maximum-changing word, and its ready binary H numeral. All values used as class labels are finite fields.

10.2 Partition the completed rows into finitely many nested families

Put T=4b+8, a machine constant. Rows with H at most T have a finite complete width profile; their membership can be accumulated in a T-bit source mask and queried by a finite length counter. Their classification is obtained from the bounded H-ruler and the finite end mask. Their literal coverage was already checked.

For H>T, use the finite label

$$(\mu,\rho)=(\text{the b-bit end mask},\ H\bmod(b+1)).$$

There are at most 2^b(b+1) such labels. Within one label, equal maxima give equal profiles. Distinct maxima differ by at least b+1. If H’<H are two such maxima, the H-profile contains every length at most H-b-1, and H-b-1 is at least H’. It therefore contains the entire H’-profile, including any of its occupied end levels. Each label is consequently a nested family, even though profiles in different labels may cross.

For each left source, maintain one pending maximum receipt from section 7 in every large-row label, and the finite small-row mask. During every actual intermediate-name bit, service every fixed receipt at its own fixed rate q. At its delimiter, the frozen right row’s ready label selects the receipt to which a new comparison job belongs. Exact ordinary-name deduplication still applies. Missing rows add nothing. All source receipts are committed by the inherited capsules; they have a machine-constant number of roots.

Each large label has at most K different final radii. Its representative can therefore improve at most K-1 times. Reuse the binary comparator, name-deficit estimate and absolute threshold service claim from section 7 verbatim. A maximum representative denotes the exact union within that label; no comparison of arbitrary membership streams is performed.

10.3 Repair before the first possible hole

A profile of maximum H contains every positive length at most

$$M(H)=H-b-1.$$

For large rows H>T this is at least H/2. Give each label’s query worker rate 8B, where F(H) is at most BH as in section 3. A promotion from H is discovered by query position ceil(H/8), measured from query start. Since M(H) is at least H/2, this is no later than ceil(M(H)/4).

Create a separate promoted-reader lane, with its H-ruler and finite end mask, and replay the unary query-prefix debt at rate four exactly as before. The section 4 catch-up inequality now uses M(H): the new lane aligns by the last position where its predecessor is guaranteed positive, before any hole of that predecessor can matter. Keep at most K lanes per large label, without canceling a repair when another promotion occurs.

An aligned reader advances its ruler once per target bit. It reports false after overflow. Otherwise its bounded remaining-ruler test determines whether the current length is within b of H; the finite mask supplies the answer there, and all earlier positive lengths are present. Exact exhaustion is membership at H, not overflow. Small-profile masks use their finite length state. Return the OR of these fixed lanes and the small-profile answer; complement for SAT on the final delimiter.

Every aligned lane represents an actually selected row, so it cannot cause a false positive. Until a successor aligns, its predecessor covers the entire query prefix under consideration. If the relevant queue remains unfinished, the absolute threshold bound puts the current query position within that same guaranteed prefix. Induction over the at most K-1 promotions proves that ignoring unaligned lanes never hides a positive answer. Thus holes and crossings cause no unresolved final-symbol observation.

10.4 Resource contract and significance

One machine is fixed for b,K; neither grows with its input. Gap pushes are paid by excess target bits, gap pops and bad-row changes by delimiters, and moving-window capture by the already required width descent. Literal validation, current maximum classes, binary numerals, finite residues and mask updates are all prepared while ordinary right input arrives. There is no preassigned row type and no global alias rewrite. Freezing this own-row metadata only after the right gate is what the copied-stream export discarded.

The left phase has a fixed number of name-routed dictionaries, queues, comparators and fields. The query has at most K times 2^b(b+1) large reader lanes and a fixed small-profile mask, with separate constant service for each. The existing simultaneous-record compiler therefore gives fixed degree, fixed radius, finite labels/control and old-top updates. Initialization is empty storage and finite control. All speculative paths, discarded gap versions, counters, pending jobs and query repairs are retained in the charged history: $O_{b,K}(N)$ logical records, $N+1$ physical scaffold nodes and $O_{b,K}(N\log(N+2))$ explicit pointer bits. There is no EOF work, padding, advice, supplied decomposition, identity test or address/timing/control side channel.

The useful criterion is broader than nesting of the entire family. A finite locally maintained descriptor can split crossing profiles into finitely many nested families, each with a long guaranteed answer prefix and a cheap radius comparator. The bounded window and unit gap stack supply that descriptor from ordinary input here. This closes the copied crossing-pair test for a checked native subclass. Section 11 carries the next dependency through one missing level at an unbounded distance, where the finite window no longer reaches it; multiple arbitrary holes remain open.

The bounded-end-defect audit independently checks the gap/window invariant, exact final gate, nesting partition, literal completeness and selected-union semantics; it also exercises the inherited pending comparator and modified repair deadlines. These finite checks supplement the written all-length proof. No root-ledger admission or priority claim is made.

11. One missing level may be arbitrarily far from the maximum

The next dependency can also be closed. For one missing level, a streamed first moment exports its position; literal completeness forces enough future own-row input to finish the background term. This removes the bounded-distance condition in this case.

Written native theorem. In the ordinary right-first Horn encoding, require every nonempty final right row to be a complete binary ball of one common, input-learned maximum H, with at most one whole positive level omitted. The omitted level may be anywhere below H and may vary between rows. One fixed deterministic native scaffolding automaton checks the condition and recognizes SAT, with bounded work and allocation per actual symbol and immediate final output. There is no bound on the number of different final omitted levels, row interleaving, intermediate profiles, duplicates, name lengths or left fanout.

The common maximum is a real restriction. This theorem does not allow independently varying maxima or two omitted levels per row. It does include arbitrarily many crossing profiles, not merely a fixed two-profile promise. Its PEG conclusion is for reversal of the checked language, and its composition is serial right-first reuse.

11.1 Bounded local decrement and signed counters

We need unit decrement as well as the run-counter increment from section 1. This is a written extension, not an assumption of arbitrary binary subtraction. In a positive canonical least-significant-first run numeral, decrement a leading one run as follows. If its length exceeds one, replace its first bit by a one-unit zero run and retain the remaining one run and tail. If its length is one and a following zero run exists, remove it and extend that zero run by one unit. If the numeral is just the single bit one, return zero.

For a leading zero run of length k, borrow from the following one run. Reuse the k-unit length stack as a one run and apply the preceding one-run operation to the following part. In the special case where that following part is just a single high one, discard the resulting high zero: the result is the k-unit one run alone. The other cases preserve canonical alternating runs. Only a bounded number of run records and top unit cells is inspected or allocated, even when k is large.

A signed counter consists of a sign, this binary magnitude, and a unary magnitude stack. A unit change pushes or pops the unary stack and applies the corresponding binary increment or decrement; reaching zero normalizes the sign. All are bounded immutable operations. Copying a counter or negating its sign copies roots and finite fields. No arbitrary addition, multiplication or equality of addresses is used.

11.2 Stream the sum of occupied widths

For each row retain the gap stack g from section 10, and the sum

$$S=\sum_{j\text{ occupied}}j$$

in both unary and run-binary form. During a target of length n, prepare a speculative copy S+n by unit increment on each actual target bit. The existing width dictionary decides at the delimiter whether this is its first occupied target at width n. Commit the speculative copy exactly in that case; otherwise retain S. Thus arbitrarily large additions are paid by the actual word and no unknown first-occupation flag is needed early.

The row also retains a triangular-term worker for its current maximum H and a signed difference counter Delta. If t is the number of units emitted so far by that worker, the invariant is Delta=t-S.

On a strict maximum change, the target delimiter installs the new ready H-ruler, resets the worker to t=0, and sets Delta=-S by copying the already prepared magnitude roots and setting the sign. This is an O(1) reset, not subtraction of a large number. The abandoned worker’s work and storage remain charged.

11.3 A forced completion window for the triangular worker

The worker has an outer cursor initially equal to the H-ruler and an inner cursor initially equal to that same ruler. An inner step pops one unit and emits one unit into Delta. When the inner cursor is empty, pop one unit from the outer cursor and reset the inner cursor to that new outer root. When the outer cursor is empty, mark the worker done. It emits H, then H-1, down through one units, for a total

$$T(H)=H(H+1)/2.$$

There are at most T(H)+H+1 elementary worker steps. An elementary step, including a signed-counter unit update, is a bounded local record program. Run eight such steps on each actual target bit for this row while its worker is unfinished. Pause while other rows are read. Row interleaving therefore does not consume an uncharged service assumption.

The first word at the eventual final maximum H starts this final worker at its delimiter. To pass literal completeness, the same row must subsequently receive the other 2^H-1 distinct H-bit words. They provide at least H(2^H-1) own-row target bits after release, and

$$8H(2^H-1)\ge T(H)+H+1\qquad(H\ge1).$$

There is no later maximum reset for this final H. Hence this worker is done before the row’s maximum level can be complete. This is a release-time guarantee, not credit borrowed from the word that created the job or from earlier right input. It also covers H=1. Intermediate resets waste only the bounded work already paid by actual symbols.

To combine worker progress with an unknown first-width update, keep two speculative Delta registers during each target. Both receive every unit the worker emits; one additionally decrements once per target bit. At the delimiter choose the decremented register exactly when the width is newly occupied. The same worker cursors serve both branches; counter operations are separately budgeted in each. On a new maximum, discard both and use the reset -S above. Induction gives Delta=t-S after every complete record.

When the worker is done,

$$\Delta=T(H)-S=\sum_{\substack{1\le j\le H\\j\text{ absent}}}j.$$

If g=0 this is zero. If g=1 it is exactly the unique missing width m, in a ready unary ruler and canonical binary numeral. H itself is occupied, so m<H. No hole search, division, square root or terminal conversion occurs.

Maintain global unit stacks for rows with g>1 and rows with unfinished workers, updating their contributions when each record commits. Keep the literal incomplete-level count I and maximum histogram. At the right boundary require I=0, no row with g>1, at most one occupied maximum class, and no unfinished worker. The last test is redundant on the intended class by the forced-window proof, so it does not discard otherwise valid input. These local tests are exactly the theorem’s structural gate. Empty right input is handled by the existing missing-row convention.

11.4 A selected union settles on its first different hole

Freeze the right dictionary. Its row terminal now says either full ball, or one hole with ready m-ruler and m-numeral; it also supplies the H-ruler prepared from actual input. The histogram gate ensures that H is common without a free numeric comparison at lookup.

A left-source receipt stores an exact selected-name trie, an optional first selected row, a strict comparison FIFO and one comparator, and a finite full-ball flag. Selecting a full ball sets that flag immediately. Otherwise retain the first selected hole m as candidate. Each later distinct selected one-hole row becomes a job comparing its missing width with m by the incremental binary comparator. Equality discards the job. The first inequality sets the full-ball flag and discards the queue, because the union of two balls with different single missing levels is the whole common ball. Every later selected row is then redundant semantically. This stopping rule requires no bound on the number of final hole types.

Service the queue at rate q at least 4a during every actual intermediate-name bit, before releasing that record’s job. The candidate m never changes while the receipt is unsettled. Every comparison costs at most C(m), even if the other hole is much larger. Exact name deduplication and the busy-period argument of section 3 therefore bound the work to exhaustion or settlement by F(m), at most Bm. All queues and suspended source versions are retained and charged as before.

During the target pin, run the H-ruler and m-ruler from their roots and give the worker 4B steps per target bit. It exhausts the queue or settles by position ceil(m/4), which is at most m. The candidate already answers every length at most H except m; only a query ending at m needs to know whether another selected row fills its hole. That decision is ready by then. Distinguish exact m-ruler exhaustion from having passed m, and H exhaustion from overflow, using finite flags. An empty receipt gives empty membership; a settled receipt uses the H-ruler alone. Complement membership for SAT at the final delimiter. No reader promotion or replay is needed in this case.

11.5 Native resources, controls and the remaining question

The number of roots, fields, speculative registers and service lanes is fixed independently of H, the number of rows and the number of final hole types. Each worker step is bounded local; a fixed number is unrolled per actual target bit. S, the signed difference and speculative alternatives use only unit updates. Their unary storage is charged by those actual operations, not by allocating T(H) all at once. The simultaneous-record compiler supplies fixed degree, fixed radius, finite labels/control and old-top semantics. $O(N)$ logical retained records, $N+1$ physical scaffold nodes and $O(N\log(N+2))$ explicit pointer-serialization bits suffice, including discarded epochs and queries. Initialization is empty storage and finite control. Every name route, preparation step, old observation, allocation and final output is included.

The construction uses no supplied palette, advice, padding, ready external handle or identity/address/metadata/timing side channel. The large complete-level input is required by the language itself and is checked literally; it is not appended computational padding. The exact future service inequality distinguishes this worker from the whole-record correction route that failed earlier release-time tests.

This gives a second structural mechanism beyond a finite partition into nested families: a union becomes final after one distinguishing witness, and the only unresolved observation has a query length that funds its cheap comparison. The first-moment export makes that witness available through ordinary names. General two-profile recognition and independent-store joins remain open.

The next decisive test is two missing levels at arbitrary positions below a common maximum. The local gap gate already supports g at most two, but the single first moment gives only their sum and does not identify the missing pair. Seek a paid export of both missing positions or an equally exact queryable missing-set representation, with the same release-time and final-symbol guarantees. Do not treat a sum as a locator: distinct missing pairs can have the same sum.

The single-hole audit checks signed run updates, speculative moment accounting, interleaved worker releases, literal completion, the exact missing-width export and pending selected unions. Together with sections 9–10 this is one combined extension assessment; no additional run or major-result count is assigned to the dependent steps.

12. Bounded missing sets have a deadline-safe reuse interface

Written prepared-interface theorem. Fix $r$. Suppose every nonempty right row has the common ball $B_H$ as its envelope and exports its exact missing set $E_v\subset\{1,\ldots,H-1\}$, of size at most $r$. An export consists of at most $r$ directly available pairs: a unary ruler and a canonical binary numeral for each missing position, plus the common $H$ ruler. Empty slots and empty rows are distinguished. Preparation of these exports is a premise here, not free work in a native recognition theorem.

Then arbitrary named selections of these rows have persistent, deadline-safe union receipts. There is no bound on the number of distinct missing sets, on selection fanout, or on ratios between missing positions. Each actual ordinary-name bit and each query bit pays a fixed amount of local work, depending on $r$ but not on the number or size of selected rows.

12.1 Anchor the possible exceptions once

For a source, ignore empty right rows and deduplicate selected ordinary names using the existing serial dictionary. At the first nonempty selected row, copy its at most $r$ hole exports into fixed lanes. These are the only possible exceptions to the eventual union, because

$$\bigcup_{v\in V}(B_H\setminus E_v) = B_H\setminus\bigcap_{v\in V}E_v.$$

A lane anchored at $m$ stays active exactly while every processed selected row contains $m$ among its holes. New rows can delete a lane; they never create a new candidate or change its ruler. Each active lane has a strict FIFO and one incremental membership test. Enqueue one bounded tuple of hole numerals for each later distinct selected name. A membership test compares $m$ against at most $r$ numerals, stopping at the shorter numeral in each comparison. The canonical binary comparator of section 4 gives a constant $a_r$ such that one entire job, including queue and slot handling, costs at most

$$C_r(m)=a_r\bigl(1+\lceil\log_2(m+1)\rceil\bigr).$$

This remains true when another hole is enormously larger than $m$. Equality with any slot completes the job successfully; exhaustion of the bounded list deletes the lane and discards its remaining queue. A row with no holes deletes all lanes immediately. Duplicate selections may service old work but release no new job. All service during a record occurs before its new job is released at the delimiter; its own spelling is not retroactive credit.

12.2 A query only needs to settle a lane at its own position

Give every lane $q_r\ge4a_r$ steps per actual intermediate-name bit. The last-busy-period argument from section 4 applies independently to each lane: there are at most $2^d$ distinct binary names of length $d$, so unfinished work through either queue exhaustion or lane deletion is bounded by

$$F_r(m)=C_r(m)+\sum_{d\ge1}2^d\bigl(C_r(m)-q_rd\bigr)_+ \le B_rm,\qquad B_r=32a_r.$$

The first term charges the busy period’s first release. Work already done, long names, duplicate names and early lane deletion only improve this bound. No prefix-free naming hypothesis or ordering by name length is used.

During a query, service each lane for $4B_r$ steps per actual target bit. Read the common $H$ ruler and every original candidate ruler simultaneously. Keep exact-exhaustion and overflow flags separately. At query length $n$, a lane can affect the answer only when $n=m$. By then its queue has exhausted or the lane has been deleted, since $F_r(m)/(4B_r)\le m/4\le m$. For $n\ne m$, the candidate ruler excludes that lane without needing its job queue to finish. Thus membership is true exactly when the envelope reader accepts and no surviving candidate equals $n$. No ruler promotion, rewind, root extraction, or final-symbol work drain is needed.

Every saved source receipt remains immutable and queryable. A query forks its own finite tuple of worker roots; it does not mutate shared old receipts. The name dictionary, queues, binary cursors, unary rulers and fixed lane control use the same simultaneous old-top compiler as sections 4 and 11. For fixed $r$, allocation and observations are $O_r(N)$ across actual input; the physical scaffold has one new node per symbol and pointer storage $O_r(N\log(N+2))$. This is a prepared serial-reuse theorem. An independently completed store still needs a paid ordinary-name route to these exports; this statement does not silently supply one or prove an independent-store join.

13. A native export for one hole in each fixed color

Written native theorem 56. Fix a finite-state unary coloring $c$ of positive lengths, with a fixed finite color set $\Gamma$. In the ordinary right-first Horn format, restrict every nonempty final right row to a common input-learned maximum $H$, with complete binary levels at every occupied width, and at most one omitted width of each color below $H$. This checked language has one fixed deterministic native scaffold recognizer. Intermediate width sets, row order, duplicate words, interleaving, ordinary name lengths, left fanout and final missing-set diversity are unrestricted.

The coloring is part of the fixed machine, not an input-supplied decomposition or advice. For parity this allows two arbitrarily placed holes whenever one is odd and one is even. It includes zero or one hole. Arbitrary same-parity pairs are not covered. Fixing more colors gives a family of fixed machines, not one machine with an uncharged growing number of registers.

13.1 Stream the colored gap and first moment

Let $W$ be a row’s occupied widths and $H=\max W$. Maintain, for each color,

$$g_c=|\{j\le H:c(j)=c\}|-|\{j\in W:c(j)=c\}|, \qquad S_c=\sum_{j\in W,\ c(j)=c}j.$$

Each $g_c$ is a unary unit stack. Each $S_c$ has both a unary magnitude and canonical run-compressed binary numeral, using section 11.1’s constant-local signed unit operations. While an actual target of length $n$ arrives, the fixed coloring automaton advances once per bit. Its newly built unary ruler stores the current color at each position. Whenever that bit is strictly beyond the old maximum, push one unit onto the corresponding $g_c$. At the delimiter, first occupation of $n$ pops one unit from $g_{c(n)}. The width dictionary supplies freshness only at that delimiter.

For every color retain a speculative $S_c+n$ counter, incremented once per actual target bit. At a fresh-width delimiter choose the speculative counter only for $c(n)$; all other colors retain their old totals. At a duplicate width choose all old totals. There are only $|\Gamma|$ such candidates. The extra work and roots are therefore fixed, although the total values are not. The final structural gate is $g_c\le1$ for every color. Testing the top two unit cells suffices. A global bad-row stack is updated from old and new row flags at each record commit, as in section 11; arbitrary invalid intermediate states are allowed.

13.2 One triangular worker exports every colored hole

For the current maximum run the same descending triangular worker as section 11. Its outer and inner rulers start at $H$. When the inner ruler is nonempty, pop it and emit one unit of the color stored at the current outer ruler top. When the inner ruler empties, pop the outer ruler and copy the new outer root into the inner register. Outer colors are retained labels, so this requires no inverse transition of the coloring automaton. Completion gives

$$T_c(H)=\sum_{1\le j\le H,\ c(j)=c}j.$$

Maintain signed $\Delta_c=t_c-S_c$, where $t_c$ is the worker’s emitted count for that color. It is a proof variable, not an extra arithmetic primitive. At record start fork two versions $A_c,B_c$ of each $\Delta_c$. A worker emission of color $c$ increments both versions of that component. Every actual target bit decrements every $B_c$ once. At the delimiter choose $B_{c(n)}$ only if width $n$ is fresh, and choose $A_c$ for all other components. A strict new maximum discards the old worker, starts the new one from the ready labeled ruler, and resets every $\Delta_c$ to $-S_c$ by copying roots and a finite sign. No large subtraction or scan occurs at this reset.

Run eight worker steps per own-row target bit. The final maximum’s first word releases the final worker. Literal completeness of that maximum forces at least $H(2^H-1)$ subsequent own-row target bits. The worker uses at most $T(H)+H+1$ steps, and

$$8H(2^H-1)\ge T(H)+H+1\qquad(H\ge1).$$

Thus the final worker finishes before the maximum level first becomes full. Later fresh smaller widths update the signed differences while the worker remains done. Its counters already track those updates; there is no late recompilation of the completed export. A global unfinished-worker stack can be included in the right boundary gate and is redundant on the stated class. No symbols of another row, earlier discarded epoch, padding, or end marker are needed in this completion argument.

At the right boundary, literal completeness, one common maximum, no bad row and no unfinished worker give

$$\Delta_c=T_c(H)-S_c= \begin{cases} 0,&g_c=0,\\ m_c,&g_c=1, \end{cases}$$

where $m_c$ is the unique missing width of color $c$. Its unary ruler and canonical binary numeral are already roots of $\Delta_c$. The existing literal validator and maximum histogram check their own conditions; neither colored moments nor the gap test substitutes for literal coverage.

13.3 Complete the native reuse contract

Apply section 12 with $r=|\Gamma|$. Color labels permit an even simpler job: compare the candidate of color $c$ with that row’s hole of the same color; an empty slot deletes the lane. The general bounded-list proof is retained because it isolates the reusable interface independently of this producer.

Initialization uses empty stacks, empty dictionaries and fixed finite state. Every right operation above is carried during ordinary right-name/target input or by a bounded delimiter commit. Every left operation is carried during ordinary source/intermediate names or query target input. All old-storage observations, routing, speculative counter updates, discarded epochs and new logical records cost $O_c(1)$ per actual encoded symbol, including the final symbol. The compiler fixes degree, radius, finite labels and control once $c$ is fixed; it preserves old-top semantics. Retained logical storage is $O_c(N)$, physical nodes $N+1$, and encoded pointers $O_c(N\log(N+2))$. The output complements relation membership to answer the terminal Horn SAT pin. Native recognition yields a PEG for the reversal of this checked language, not automatically for its forward spelling.

This completes a structural subclass, with no new root admission or novelty claim. The decisive feature is a bounded set of named possible exceptions whose tests get cheaper at short queries, together with a paid producer of those exception names. It is stronger than merely storing a small semantic summary and narrower than a general relation-composition theorem.

14. Why two unrestricted holes are still a different export problem

14.1 A finite coloring menu does not remove the gate

Any fixed finite collection of unary finite-state colorings has a joint ultimately periodic coloring. Beyond its common preperiod, choose distinct $a,b$ separated by its positive period. Every coloring gives them the same color. Therefore no fixed finite menu guarantees a one-hole-per-color export for all two-hole sets. For modular colorings the least common multiple of the moduli is an explicit period. This is failure of the finite-color selection route, not a native lower bound. There is also an exact collision if the one-hole gate is simply removed. Choose $a$ beyond the common preperiod and a common period $P>0$. The sets $\{a,a+3P\}$ and $\{a+P,a+2P\}$ have the same count and first moment in every color of every member of the menu, but different membership answers. Give both rows the same maximum above $a+3P$. Thus even all these colored first moments together fail to determine the unrestricted two-hole set. A data-dependent unbounded coloring needs its own charged construction, state representation and readout theorem.

14.2 Exact first and second moments can still have slow local access

Two distinct missing positions are semantically determined by their count, first moment $S$ and second moment $Q$: their sum is $S$, their product is $(S^2-Q)/2$, and they are the roots of the resulting quadratic. This algebra does not supply native multiplication, square root, sorted roots, or an immediate test at a short target.

Here is an explicit restricted readout obstruction. For $L\ge6$, set $M=2^L+2$ and use the common maximum $H=M+1$. Compare

$$E_A=\{1,M\},\qquad E_B=\{2,M-1\}.$$

Both have count two and $S=M+1$. Their second moments are

$$Q_A=2^{2L}+2^{L+2}+5,\qquad Q_B=2^{2L}+2^{L+1}+5.$$

The common envelope and a one-bit target are the same, but membership at length one differs. Consider an export containing only count, $H$, $S$ and $Q$, with each magnitude represented by a private unary stack and a canonical LSB-first run-compressed numeral. Run lengths are private unary stacks; run-head links expose the run sequence, and there are no additional jump, shared-equality, address, metadata, timing or producer-control channels. The two $Q$ run-length lists are exactly

$$(1,1,1,L-1,1,L-3,1),\qquad (1,1,1,L-2,1,L-2,1),$$

with alternating labels $1,0,1,0,1,0,1$. All other exports agree. Even granting free access to every run head, the differing length stacks have identical prefixes through $L-4$ cells. A local consumer must reach the end of at least one of them, or travel even farther in a magnitude stack, to distinguish the two cases. For a fixed observation radius this costs $\Omega(L)$ local work. Arbitrary interleaving, caching and negative observations do not reveal a termination that has not been reached. Any preprocessing performed after this export counts toward that access work.

Consequently this particular exact two-moment representation cannot answer the constant-length late pin with bounded local work unless it has already paid the extra inspection and exported a richer answer. This is a representation bound only: the actual right producer has substantial genuine input time and may retain richer information. Indeed, both examples satisfy the parity-colored theorem above, whose separately maintained first moments export the holes directly. The obstruction therefore has a native escape inside the very same example family.

14.3 Sustained construction attempts and the surviving target

We considered emitting higher moments with fixed-depth unary-loop workers. For fixed moment order, a complete level has exponentially many words and can in principle fund polynomial work. This gives a possible time source, not a completed compiler: width freshness is learned at a delimiter, shared accumulators need coherent updates, and late small widths may alter the roots just before the right boundary. Charging total work alone does not solve those release and access obligations. We do not claim a native higher-moment export or root-extraction algorithm.

A scan of the final width dictionary finds the holes in $O(H)$ steps but is not allowed after the right boundary. Restarting such a scan after every fresh width can leave a last short record with an unpaid $H$-step restart. A snapshot scan with later repairs avoids that particular restart only if its late deletions and stored positions remain coherent and immediately readable; that mechanism is not supplied here. These are failed completion arguments, not impossibility results for all scans or all persistent representations.

The reuse half is now separated cleanly from that producer problem. The route-level target, subsequently closed by section 15, is an ordinary-input export of the two arbitrary missing positions as ready unary/binary pairs, or a comparably cheap name-relative membership interface. It must handle two holes in the same color of every fixed finite palette, a very small hole beside a very large one, and late small-width insertions, without a boundary scan, fresh root extraction or uncharged pointers. Common $H$ remains fixed across rows; varying maxima and independent-store joins remain separate frontiers.

The finite checker tests streamed colored exports, final-gap rejection, persistent union receipts, all-prefix query answers and the moment-prefix obstruction. Python integers and containers are independent semantic oracles, not a native cost model.

15. Arbitrary bounded missing sets have a native gap-list export

Written native theorem 57. For every fixed $r\ge0$, ordinary right-first Horn SAT restricted to nonempty right rows with one common input-learned maximum $H$, complete binary levels at every occupied width, and at most $r$ missing widths below $H$, has a fixed deterministic native scaffold recognizer. Missing positions are arbitrary. There is no color, end-window, width-ratio, ordering, live-hole, final-profile-diversity or left-fanout bound. All final restrictions are checked from ordinary input.

In particular this closes the two-arbitrary-hole target left by section 11. The producer below works even with unboundedly many intermediate holes. It supplies section 12’s exact ready position exports at every record boundary, so it needs no triangular worker, moment inversion or forced future input. Sections 13–14 retain useful controls on the earlier arithmetic route, but their unrestricted-hole frontier is resolved by this different representation.

15.1 Store the exact missing list, with gaps and absolute names

For a row with occupied widths $W$ and maximum $H$, write its missing positions in increasing order as $e_1<\cdots<e_g<H$, and put $e_0=0$. Store a persistent list whose $i$th payload contains three ready roots:

• a unary stack of length $d_i=e_i-e_{i-1}$;
• a unary ruler of length $e_i$;
• the canonical binary numeral of $e_i$.

Also retain the unary $H$ ruler and a unary count $g$. The absolute position roots are immutable payloads, never reconstructed by summing gaps at query time. The list uses explicit nodes and normalized unary path capsules. A capsule contains a strict FIFO of payload frames and an explicit node or empty terminator as its tip. One-level view exposes the first frame, with the remaining capsule as its tail; if no frames remain it exposes the explicit tip. It never recursively follows a capsule tip into another capsule.

This is the unary specialization of the pointer-valued serial dictionary in reader section 12.2. Its frame-fold invariant does not require one frame per input letter: here at most one old or newly confirmed hole frame is captured per target bit. FIFO payloads are fixed-arity opaque references, as in that existing interface. No arbitrary concatenation operation is assumed.

Initially $H=g=0$ and the missing list is empty. A target word of length $n$ provides exactly $n$ real input bits. Ignore their values only for this width maintenance; the independent literal validator still reads them all.

15.2 Prepare a possible deletion while approaching each hole

At the start of a target, view the first missing node and its successor. Suppose the current node is at $a$, its predecessor is at $b$ (or zero), and its successor, when present, is at $z$. The stored current gap is $d=a-b$; the successor’s stored gap is $e=z-a$.

While the actual target advances from position $b+1$ through $a$, pop one unit of a cursor for $d$ per bit. In parallel, start a candidate merged gap at the ready old root for $e$, and prepend one unary cell per arriving bit. At position $a$ the candidate is therefore exactly $e+d=z-b$. This copies only the left gap, one unit per real symbol; it never traverses the possibly enormous right gap. If the current node has no successor, no merged gap is needed.

Retain a FIFO of unchanged earlier hole payloads. If the target delimiter occurs exactly at $a$, remove the current hole. With a successor, make one explicit successor node containing the prepared merged gap, its unchanged absolute position roots, and its unchanged tail. Without a successor, use an explicit empty tip. Close the captured prefix around that tip and pop one unit from $g$. Every delimiter action is bounded, independently of $a,d,e$.

If another target bit follows instead, append the unchanged current payload to the prefix FIFO, advance to its successor, and begin that next interval’s merge candidate. This advance occurs on the next actual bit, before processing that bit’s unit of gap. A positive gap ensures at most one node is passed per bit. The previous candidate is discarded, with its work charged to the bits that built it. If the target ends strictly between holes and does not exceed $H$, keep the old missing-list root unchanged: that width was already occupied. Freshness is thus known at the delimiter from the exact cursor, without advice or a speculative mutation of the old list.

For example, if the current holes are $2,63$, a two-bit target can remove $2$ by prepending two cells to the stored gap of length $61$. It exports $63$ immediately. It does not traverse sixty-one cells, add two unbounded integers, rewrite the position numeral, or repair an old alias.

15.3 Extend a maximum with one-bit-delayed hole confirmation

Simultaneously pop the old $H$ ruler once per bit until it is exhausted, and build the current-position unary ruler and binary numeral from zero with one unit increment per actual bit. Maintain an elapsed unary stack since the last passed hole. Reset it when that hole is captured; otherwise prepend one cell per bit. While no old hole remains, this records the occupied tail’s length without needing a terminal gap in the stored list.

At position $i>H$, the current word has not yet proved that $i$ is missing: it may end there. Buffer a possible hole payload using the ready absolute position roots and the elapsed gap. If another bit arrives, position $i$ is now known to lie strictly below the new occupied width. Append that payload to the prefix FIFO, push one unit on $g$, reset the elapsed gap, and buffer the next position. If the delimiter arrives instead, discard the last potential hole and set the maximum to the current ready ruler.

Thus at a new maximum $n$ the prefix contains precisely all old holes and the new holes $H+1,\ldots,n-1$. Close it around the explicit empty tip. There is no post-delimiter append or traversal. For an initially empty row, the same process creates positions $1,\ldots,n-1$ and leaves $n$ occupied. The added binary numeral at position $i$ was built by the actual first $i$ bits of this record; no numeral conversion is postponed.

The old-hole and extension advances cannot collide in one bit. Every old hole is below the old occupied maximum, so all old payloads have been captured before extension begins. This bounds the number of FIFO operations and fresh logical records per bit by an absolute constant.

15.4 Invariant and native accounting

After every target delimiter, the list is exactly $\{1,\ldots,\max W\}\setminus W$, in increasing order, with its gap invariant and both absolute position roots correct. Induct on the record history:

1. A duplicate width below the maximum leaves the old list unchanged.
2. A fresh width below the maximum removes exactly its encountered node; only its successor gap changes, from $z-a$ to $z-b$.
3. A new maximum appends exactly the newly exposed missing interval and excludes the final occupied endpoint.

These are exhaustive and do not assume a bound on intermediate gaps or hole count. The counter $g$ follows exactly the append/delete operations. Previous row roots, lists, numerals and capsule prefixes are immutable. Different future histories can branch from the same old version without repeating any uncharged reversal or hidden normalization.

At the right boundary, a global bad-row counter checks $g\le r$ by an $r+1$-cell bounded view at each row commit, using old/new bad flags. The existing complete-level validator checks that each occupied width contains all binary words, and the maximum histogram checks one common nonempty-row maximum. The gap representation does not substitute for either gate. At most $r$ one-level list views now expose every missing position, already in both forms required by section 12. These views are a fixed delimiter batch for the chosen machine, not a scan proportional to an unbounded row.

All row lookup and restoration use the ordinary intermediate name and its suspended outer capsule. During a target bit there are only a fixed number of unary pushes/pops, one run-counter increment, bounded one-level views and strict FIFO operations. During its delimiter there are only bounded pointer copies and capsule closures. The later source and query phases use section 12’s fixed $r$ lanes. All speculative merge cells, abandoned candidates, confirmed holes, binary numeral nodes, queues, dictionary paths, old versions and query forks are included in $O_r(N)$ logical allocations and observations. The simultaneous old-top compiler fixes degree, radius, labels and control for each fixed $r$, starts from a constant empty configuration, and creates exactly $N+1$ physical scaffold nodes. Explicit pointer serialization costs $O_r(N\log(N+2))$ bits.

The final pin reads the already determined membership bit and complements it for Horn satisfiability. There is no padding, preprocessing outside actual input, supplied gap decomposition, free name routing, final scan or extra EOF step. This is a uniform fixed machine for each fixed $r$; it is not a uniform claim for an unbounded input-supplied $r$. Its PEG consequence is for the reversal of this checked ordinary language only.

15.5 Structural payoff and the next boundary

The missing-list producer replaces expensive global arithmetic by a local splice whose growing part is paid for before the update is certified. Its right-hand gap is shared, while the actual input copies just the left-hand gap. One-bit-delayed endpoint confirmation similarly pays for extension. The resulting position exports make the finite possible-exception criterion of section 12 effective. This explains why arbitrarily crossing profiles can still be reusable: a selected union has only a fixed number of candidate negative answers, and each candidate can be settled by its own query length.

The common maximum is still a real restriction. With unequal maxima, adding a larger row can introduce new candidate holes above the earlier envelope; section 12’s once-only anchor argument no longer applies directly. The next test is two arbitrary final maxima with at most two arbitrary holes per row: combine the existing pending maximum reader with these ready hole exports, charging candidate creation, copied queue debt and reader alignment. If that works, carry the same proof through fixed bounds on maxima and holes. Growing exception budgets, general radial profiles and independent-store joins remain separate. This is a written construction with finite corroboration, not a new root admission, literature-priority claim or native-language lower bound.

The explicit gap/capsule checker uses immutable cells and nonrecursive one-level capsule views. It retains and branches from old versions, tests late short deletions, and composes the exports with the independent bounded-exception receipt checker. Integer/set oracles are confined to the audit; the proof above supplies the native cost.

16. Different maxima: copied queues have a paid birth budget

Assessment 186, 10 October 2026. Written native theorem 58. Fix positive integers $K,r$. In the same ordinary right-first Horn encoding, require every nonempty final right row to be a union of complete binary levels, with at most $r$ missing positive levels below its maximum, and at most $K$ distinct final maxima globally. One fixed deterministic native scaffold automaton checks these conditions and recognizes the pinned SAT language. Final hole-set diversity, intermediate diversity, input order, duplicate records and left fanout are unrestricted. In particular this closes two arbitrary maxima with two arbitrary holes per row. The construction is serial reuse, not a free join of independently completed stores; its PEG consequence is for reversal.

The gap-list producer in section 15 already exports every row’s maximum and holes as unary rulers and canonical binary numerals. Replace its common-maximum gate by the existing histogram gate $D\le K$. No change to the gap splice or literal complete-level check is needed. The new work is in the source receipt.

16.1 Births only occur above the processed envelope

Write a row as $P(H,F)=\{1,\ldots,H\}\setminus F$, where $|F|\le r$ and $H\notin F$. If a nonempty processed union has maximum $M$ and missing set $E$, adjoining $P(H,F)$ removes each old hole covered by that row. When $H>M$, the only new possible holes are

$$F\cap\{M+1,\ldots,H\}.$$

Indeed, below $M$ an occupied position can never become missing under union. Above $M$ all previously processed rows are absent. Thus a new candidate needs no comparisons with the processed prefix. For example, a processed envelope of 5 with holes 2 and 4, followed by a row of maximum 9 with holes 4 and 7, loses hole 2, retains hole 4 and creates only hole 7. Earlier processed rows cannot cover 7.

This is a set identity, not an instruction to compute an unbounded intersection at a delimiter.

Keep one global FIFO of newly selected distinct row descriptors and an incremental maximum worker. Its current envelope $M$ is the maximum of its processed prefix. The first selected nonempty row initializes the envelope and its at most $r$ hole lanes. For each later row, compare its maximum with $M$. If it is larger, compare its at most $r$ hole numerals with $M$, retaining only those strictly greater than $M$; finish these tests before committing the promotion. At that commit create a lane for each retained hole. Each lane captures a separate persistent copy of the remaining global FIFO root. The promoting row is already removed; all older processed rows are known absent at the new hole. Each later new selection is appended to the global FIFO and every active hole lane. No queue concatenation is used.

A hole lane at position $m$ incrementally tests whether each queued row covers $m$: first compare $m$ with the row’s maximum, then, if needed, compare with its at most $r$ holes. A covering row deletes the lane and drops its queue. Otherwise it survives to the next job. Candidate positions never change. Every new position is above the previous envelope, so births from different promotions are disjoint. There are at most $Kr$ births, and at most $K$ envelope reader lanes. Fixed slots can be reserved without reuse.

All comparisons stop when the shorter canonical numeral ends. Choose one implementation constant $a=a_r$ so that a global job with old envelope $M$ costs at most $C(M)$ and a hole-lane job at $m$ costs at most $C(m)$, where

$$C(x)=a(1+\lceil\log_2(x+1)\rceil).$$

The bound includes fixed slot tests, copied queue handles, cursor setup and job completion. Global hole tests compare with the old $M$, even when the new maximum is enormous. Service each existing lane and the global worker for $q\ge4a$ steps per actual intermediate-name bit. Newly selected rows are released only at the delimiter. A lane born during a service batch receives no credit for any earlier input; service after birth is charged separately.

16.2 Count copied jobs, not inherited service

Queue cardinality bound. At a promotion from $M$, the captured suffix contains at most

$$D(M)=2+2^{C(M)/q+1}\le8(M+1)^{1/4}$$

jobs. The same bound holds if promotion happens during the final query.

For proof, replace every global job through this event by a job costing exactly $C(M)$, including subsequent queued jobs for this comparison only. Every earlier candidate was at most $M$, so the inflated FIFO cannot finish any job sooner than the actual FIFO. With the identical distinct-name arrivals and service its residual work at a left boundary is at most

$$F(M)=C(M)+\sum_{d\ge1}2^d(C(M)-qd)_+\le32aM.$$

This is the last-busy-period calculation of section 3. If $n$ jobs remain in the inflated FIFO, all but its possibly partial first job still cost $C(M)$, so $n\le1+F(M)/C(M)$. Bounding the geometric sum gives $n\le D(M)$. The actual remaining jobs are a suffix of these jobs. During an intermediate name, service only decreases their number until its delimiter release; the preceding boundary bound therefore suffices. During a query there are no new arrivals. Inflate the history through the desired promotion; the same boundary bound still applies, even if earlier query promotions occurred. Finally $C(M)\le a(2+\log_2(M+1))$ gives the displayed fourth-root estimate.

A lane born at $m>M$ may therefore start with at most $D(M)C(m)$ fresh work. It does not inherit past service from the captured FIFO. The inequalities $M+1\le m$, $\log_2(m+1)\le2\sqrt m$, and $m\ge1$ give the conservative bound

$$D(M)C(m)\le8a m^{1/4}(2+\log_2(m+1))\le64am.$$

Future arrivals contribute at most the ordinary distinct-name busy-period bound $F(m)\le32am$. More explicitly, if the seeded busy period persists, its residual is at most initial work plus the sum of positive subsequent arrival deficits. If it empties, the usual last busy period starts anew. Thus a lane born before the query has at most $96am$ residual work through queue exhaustion or deletion. An initial lane has no seed and satisfies the smaller $32am$ bound. This argument charges copied payload comparisons anew, including copies subsequently abandoned after a covering witness.

16.3 Both the birth and the reader fit before position m

Give the global query worker $R_0=128a$ steps per actual target bit. The threshold argument of section 7, using the new $C$, discovers each promotion from $M$ by the absolute query position

$$\tau\le\lceil M/4\rceil.$$

Its at most $K$ envelope readers use the same independent four-step prefix repair. They determine whether the target length is below the final union maximum by the final-symbol deadline; holes do not affect this envelope test.

Give each hole lane $R_1=384a$ steps per target bit. A lane existing at query start settles by $\lceil m/4\rceil$. A lane born during the query captures at most $64am$ fresh work and receives service starting in its birth batch. Even allowing service only from the next bit, it settles by

$$\tau+\lceil m/6\rceil\le m\qquad(m>M\ge1).$$

For $m=2,3$ check directly. For $m\ge4$, use $\tau\le\lceil(m-1)/4\rceil$ and the displayed ceilings. Actual earlier service or lane deletion only improves this deadline. The global batch runs before hole-lane service, so no release relies on a later operation in the same symbol.

An initial hole ruler starts aligned at query position zero. A newly born hole ruler captures the actual query-prefix unary stack and performs the four-step catch-up from section 4, beginning in its birth batch. Its alignment finishes by position $M$, hence strictly before its own position $m>M$. If that bound is already reached in the birth batch, the bounded batch performs the corresponding bounded repair immediately. Each lane has its own paid repair work; shared prefix roots are not free replay.

At an arbitrary query endpoint $n$, an unaligned newborn cannot equal $n$: its birth position and all subsequent unaligned positions lie below $m$. Every aligned lane tests exact equality with its fixed ruler. Any lane with $m=n$ has already exhausted its comparisons or been deleted. Answer membership exactly when the envelope accepts and no surviving hole lane equals $n$. Complement that bit for the terminal Horn SAT pin. No final queue drain is performed, and no eventual query length is known in advance.

16.4 Why this is the exact union, including unfinished work

At every global processed prefix, all its possible missing positions occur among the lanes born so far. Each lane’s queue contains precisely the still untested selected rows outside the prefix it was allowed to omit at birth; that omitted prefix has maximum less than the lane’s position. A lane may already have been deleted by a selected row still pending globally, which is sound because selection, not global processing order, determines the union. These invariants follow by induction on arrivals, job completions and births.

If $n$ is in the selected union’s envelope but absent from the union, some processed envelope must reach $n$ by its envelope-reader deadline. Either $n$ was an initial hole or the first such promotion created its lane. No row can delete it. If $n$ is present, every lane at $n$ is deleted by its covering row by position $n$, or it was never a candidate. Positions outside the final envelope are rejected independently. This proves both directions without requiring a completed semantic summary before the query begins.

16.5 Native resources and structural criterion

Reserve $Kr$ hole lanes, $K$ envelope reader lanes, the global FIFO/worker, and the existing parser, name dictionaries and producer roots. Their number is fixed for the chosen $K,r$. Each birth copies boundedly many root fields; a strict immutable FIFO can be forked at its current state and advanced or extended separately, using the existing bounded local implementation. No past service is shared between those forks. Every simultaneous lane receives its own fixed service allowance and bounded allocation batch per real symbol. All old storage observations, queue forks, discarded jobs, numeral traversal, source restoration and reader repair are thereby charged.

The existing compiler fixes degree, radius, finite labels/control and old-top updates. Initialization is constant and empty. Across encoded length $N$ the logical work and retained allocations are $O_{K,r}(N)$, including abandoned versions; physical scaffold nodes are $N+1$ and explicit pointer storage is $O_{K,r}(N\log(N+2))$. There are no supplied handles, decompositions, padding, advice, free preprocessing, address tests or EOF steps. Invalid input is rejected by the maintained syntax and structural gates. This is one machine for each fixed $K,r$, not a nonuniform choice based on the input maxima.

The useful criterion is stronger than bounded semantic description: new exceptions appear only beyond a previously processed envelope, their copied queue has sublinear cardinality in that envelope, and logarithmic tests turn that seed into a linear budget before its first relevant observation. Merely bounding the number of promotions would not pay for an arbitrary copied queue.

The next decisive target is to remove the fixed maximum-diversity bound while keeping a fixed hole bound. Can obsolete lanes be retired and their slots reused with bounded outstanding reader debt, or is there a deadline witness for this birth-and-repair architecture? Unbounded hole budgets, arbitrary radial profiles and independent-store joins remain separate frontiers.

The finite audit checks copied jobs as fresh debt, immutable query forks, late births, envelope promotions, reader repair and every tested query endpoint against direct row unions. Worst-case job durations are normalized model costs, not measured Python runtime.

17. Unbounded promotions need only fixed live slots

Assessment 187, 10 October 2026. Written native theorem 59. Fix a nonnegative integer $r$. Require each nonempty final right row, in the same ordinary right-first Horn encoding, to consist of complete binary levels with at most $r$ missing positive levels below its maximum. There is no bound on the number of distinct maxima, distinct row profiles, or maximum changes. One fixed deterministic native scaffold checks this condition and recognizes the pinned SAT language with bounded work and allocation per actual symbol and immediate final output. Serial reuse and reversal remain the orientation qualifications. No independent-store join or general radial theorem follows.

The producer is section 15. Retain the literal complete-level and final hole-count gates, but omit the maximum-diversity gate. No new producer or supplied export is needed. The consumer below uses at most $r$ live hole slots and two envelope reader slots, independently of its lifetime births.

17.1 Retire by a covering witness, not by slot age

Modify each global FIFO job in section 16 to test its row against every currently live old candidate before committing. A covered candidate can be retired. If this row raises the envelope from $M$ to $H$, retain each uncovered old candidate and add precisely its holes above $M$. An old survivor is a hole of this row below or at $M$; a new candidate is a hole of this row above $M$. Their positions are disjoint, and together they are a subset of the row’s at most $r$ holes. Thus there is room in the fixed pool after retiring covered candidates and before installing the new ones. A nonpromotion only removes candidates. The first row installs at most $r$ candidates directly.

Independent hole workers may still retire candidates earlier, on a covering selected row not yet processed globally. This is sound: future union cannot undo coverage. A global job snapshots its at most $r$ candidate positions when it starts and prepares the bounded deletion mask incrementally. Hole workers can only delete during that job, not create or repurpose slots. Intersect the mask with the still-live flags at commit. New births occur only at that commit, so no result can delete a different occupant of a reused slot. This is finite local generation discipline, not an address-identity test.

Charge all old-candidate-versus-row tests, the maximum comparison and the new-hole-versus-old-maximum tests to the global job. An old candidate has position at most $M$. Each comparison stops when its shorter canonical numeral ends, even when the other row’s maximum or holes are enormous. There is a constant $a=a_r$ for which the complete job costs at most $C(M)=a(1+\lceil\log_2(M+1)\rceil)$. Keep $q\ge4a$ service per actual intermediate-name bit, with release at the delimiter. The constants below include the larger job, not the cheaper section 16 job by assumption.

A surviving candidate retains its own queue, partial comparison and reader state unchanged. A new candidate gets a fresh copy of the remaining global queue and zero inherited service. Section 16’s cardinality bound and the $64am$ seed, $96am$ prequery residual and $384a$ query-service bounds therefore apply to every incarnation separately. Retiring a lane discards its remaining work because a concrete selected row already certifies its answer forever. Its allocated history remains in storage accounting. No copied queue is concatenated with another, and no surviving lane is restarted.

17.2 The query worker gets ahead of the current envelope

The threshold claim of section 7 still holds with the larger $C$: before first exceeding any fixed threshold $T$, all complete global jobs cost at most $C(T)$. Inflating the left history and this query prefix gives at most $F(T)\le32aT$ remaining work through that event or queue exhaustion. With $128a$ service per target bit, the event occurs by $\lceil T/4\rceil$. There is no bound on the number of intervening promotions in this argument.

A useful equivalent consequence is the following progress alternative. At the end of the global batch for query position $t\ge1$, either the global queue is exhausted or its current maximum satisfies

$$M_t>4t.$$

Otherwise set $T=M_t\le4t$. The threshold claim says that by this same batch the queue has exhausted or the maximum has exceeded $M_t$, a contradiction. The maximum at query start is no larger than $T$, as required. This alternative is a proof invariant; the machine never numerically tests $M_t>4t$.

17.3 Two readers, without canceling unfinished repair

At query start keep the current envelope’s aligned unary reader $A$. Keep one empty replacement slot and a root for the global worker’s latest maximum. The worker attaches a finite dirty flag when it promotes. It runs before reader service on every target bit. If the replacement slot is empty and a newer maximum is available, capture that latest ruler and the actual query prefix stack. Repair this reader at eight unary steps per bit, including its birth batch. Do not cancel or reset it when a newer maximum arrives; retain the newest root and dirty flag for the next handoff.

When repair finishes, replace the aligned slot by this completed reader. If a newer maximum is waiting, start its repair in the same batch and give it eight steps as well. There are at most two repairs serviced in a batch: the old pending reader and the latest reader available after the global batch. No global work runs between them, so no third newer root can appear. The dirty flag is cleared at capture and set only by subsequent promotions; no arbitrary numeral comparison or pointer-identity test selects a handoff. An aligned reader otherwise takes one ordinary ruler step per target bit.

For a repair started at position $p\ge1$, its initial debt is $p$ units. Eight units are paid immediately, and later bits add one unit and pay eight. It finishes by

$$f(p)=p+\left\lceil (p-8)_+/7\right\rceil\le 8p/7.$$

All units are actual prefix cells, reread at the charged repair rate. Finite flags distinguish exact exhaustion and overflow. A replacement starting in the second repair batch has the same immediate allowance.

Suppose the aligned maximum is $A$ and a larger selected maximum exists. If $A$ was installed initially, its installation time is zero. Otherwise it was captured at some $p$. If the global queue was already exhausted at that capture, $A$ was the final maximum, contrary to the supposition. Therefore the progress alternative gives $A>4p$, and its alignment time $s$ satisfies $s\le8p/7<2A/7$. The first global maximum above $A$ is available by $\lceil A/4\rceil$. Because repair is not restarted, and because handoff can start the next reader in the same batch, the replacement of $A$ starts by

$$u\le\max(s,\lceil A/4\rceil).$$

It aligns no later than

$$f(u)\le\max(16A/49,\,2(A+3)/7)\le A\qquad(A\ge2).$$

For $A=1$, the larger maximum is found in the first batch and its one-unit repair finishes there. Thus every aligned reader is replaced before a query can pass its maximum, whenever a larger answer is needed. The final maximum need not satisfy the progress inequality after queue exhaustion: it needs no successor. This handles unboundedly many handoffs without accumulating simultaneous readers or assuming a growing gap between maxima.

Every aligned maximum belongs to a selected row, hence cannot accept beyond the true envelope. The handoff bound prevents a false negative inside it. The aligned reader alone therefore supplies exact envelope membership at every query endpoint. Unaligned readers supply no answers.

17.4 Coupling holes, slots and reader retirement

Hole-reader repair remains independent of the two envelope slots. On a new candidate $m>M$, capture the query-prefix root and use the four-step repair of section 16. Its birth is still discovered by $\lceil M/4\rceil$ and it still aligns before $m$. Existing candidates keep their aligned or pending reader state across global promotions. If either a global completed test or its independent worker finds a covering row, retire its queue and reader together. Any later occupant starts with fresh debt at its own new position.

When several global jobs commit in one symbol, each performs its bounded retirement and birth operations. At most the fixed global batch size many jobs can commit. A candidate born and retired within that batch has incurred only bounded setup work; no earlier service is credited to it. A candidate surviving to hole service receives the usual fixed allowance. It is also safe to defer a birth’s first independent service to the next target bit, as section 16’s deadline inequality already permits. Thus slot reuse does not hide a zero-time traversal of an arbitrary number of generations.

The live candidates remain a subset of the missing positions of the global processed union, with omissions justified by covering selected rows. They include every position absent from the full selected union that has entered the processed envelope. At endpoint $n$, a candidate at $n$ is settled by its birth/residual deadline or has a covering witness and has been retired. A missing position cannot be retired by either worker. Return envelope membership AND absence of a live candidate equal to $n$, then complement for SAT. This couples exact negative observations with paid branching reuse; there is no final queue drain, final scan, or eventual-length advice.

17.5 Fixed native resources and a broader structural criterion

For fixed $r$, reserve $r$ candidate/queue/comparator/reader slots, two envelope reader slots, the latest maximum root and finite flags, one global worker, and the inherited dictionaries, parser and producer fields. Each operation uses bounded old observations and a fixed allocation batch. A slot is a field in the next immutable record, not a mutable cell in retained storage. Old receipts and query forks therefore retain their own occupants and progress. The simultaneous-record compiler fixes degree, radius, finite labels/control and old-top updates. Initialization is constant and empty. All name routing, preparation, abandoned comparisons, seed copies, retirements, query-prefix repair and output are charged. Across actual encoded length $N$ this is $O_r(N)$ logical retained records and observations, $N+1$ physical nodes and $O_r(N\log(N+2))$ explicit pointer bits. There are no supplied handles, decompositions, padding, advice, free preprocessing or EOF work.

The criterion now concerns live exceptional observations, not lifetime profile diversity. Births occur beyond a processed envelope; a covering witness makes retirement permanent; logarithmic tests and distinct names bound each fresh queue; and threshold progress lets two readers cover an unbounded promotion history. Small semantic size alone would imply none of these deadlines. Theorem 58’s maximum-diversity hypothesis is removed in this subclass; unrestricted missing-level sets and independent-store joins remain open. Native recognition gives a PEG for reversal of this checked language, not automatically for its forward orientation.

The next decisive test is one contiguous interval of missing positive levels per row, with arbitrary interval length. Its two endpoints are a fixed-size semantic description, and intersections of missing intervals remain intervals, but moving endpoints may require replacing candidate readers before their first relevant query. Supply a native ordinary-input export and a paid persistent interval-union readout, or exhibit the exact deadline failure of this endpoint architecture. Do not infer it from the fixed-cardinality proof.

The fixed-slot audit checks immutable versions, bounded live slots, fresh copied debt, retirement, two-reader handoff and query endpoints against direct unions. It supplements the all-length argument; Python oracle operations are not native primitives.

18. Missing intervals: a short-query obstruction to FIFO minima

Assessment 188, 10 October 2026. Written restricted counterexample and semantic update audit; no new native recognition theorem. Theorem 59 remains the latest completed construction. This section isolates the next access obligation rather than extending its fixed-hole conclusion to intervals.

18.1 Endpoint count is not live exception count

Write a complete-level row as the set of its occupied positive lengths. A row

$$P(H;a,b)=[1,H]\setminus[a,b],\qquad 1\le a\le b<H,$$

has two missing-interval endpoints regardless of the interval’s length. Nevertheless, selecting the rows with maxima $2j$ and missing intervals $[1,2j-1]$, for $1\le j\le t$, produces exactly the occupied levels $2,4,\ldots,2t$. Its missing set inside its maximum has $t$ components. Thus the live-slot proof in section 17 does not survive merely by replacing each point slot with an interval slot. This is a failure of that invariant, not a storage or native-language lower bound. Each occupied level denotes all its binary words, whose ordinary encoded input cost is retained.

A stronger diagnostic already occurs at a common maximum. For $1\le b\le H$, put $S_b=[b,H]$. These are permitted rows with missing interval $[1,b-1]$ (empty when $b=1$). For a nonempty selected family,

$$\bigcup_{b\in E}S_b=[\min E,H].$$

This semantic identity reduces the consumer problem to a minimum threshold, but supplies neither a native minimum operation nor a reduction from some unrelated encoded language. The question is when that minimum becomes observable. Decreasing an old threshold from an arbitrarily large $B$ to 2 changes a length-two answer immediately. By contrast, an increasing ball maximum leaves the old ball’s short positive answers valid. Section 17’s threshold-progress argument has an essential direction; its logarithmic queue bound alone does not reverse that direction.

18.2 Exact failed consumer contract

Fix nonnegative $w$ and fixed service constants. Consider a consumer with the following restricted readout contract:

1. It retains a committed minimum and a strict FIFO of distinct selected-row jobs. Its head uses the full least-significant-bit-first comparison from section 1; equal numerals are read to their ends. There is no pointer-identity shortcut, preemption, job bypass or producer-supplied comparison certificate.
2. Uncommitted rows may additionally be queried through at most the $w$ most recently released row readers. Eviction is by recency. No other aggregate threshold, endpoint-class flag, searchable queue index or historical reader is available to the answer procedure.
3. Before a job reaches the head, its endpoint payload can affect answers only while present in that recent window. Routing, allocation addresses, numeral metadata, execution time and control flow provide no additional payload channel. Jobs have the same fixed header shape. Ordinary name identity is used for lookup and deduplication, not as encoded endpoint advice.
4. Each actual selection symbol permits at most a fixed number of worker steps, and each actual query symbol, including its delimiter, permits at most a fixed number. There is no post-delimiter service.

Restricted counterexample. No such consumer is exact for every selected union of common-maximum suffix rows.

Choose distinct ordinary binary names for $w+4$ rows. Select a row with threshold $B$ to initialize the committed minimum, then a separately prepared row with the same threshold to start a long equality comparison. Next select a special row, followed by $w+1$ further rows of threshold $B$. The special threshold is 2 in one history and $B$ in the other. All names, record lengths, maximum $H$, job counts and service times agree. The extra $B$ rows evict the special row even if one recent slot is reserved during release.

Let $T$ bound all worker service after the head starts through the final delimiter of a two-bit target query. Include source-name routing, intermediate-name routing, selection delimiters and initialization overhead in $T$; these are finitely many actual symbols determined before choosing $B$. Choose $B=2^L$ with $L>T+2$ and common $H=B+1$. Separate binary numerals for the two head operands require at least $L+1$ bit services to establish equality. The head therefore remains unfinished, and the special job has not started. At the query deadline, committed minimum, active comparison, recent readers, queue shape and allowed control observations agree. The hidden special payload is outside the declared observation contract. Yet the length-two answer is true in the first history and false in the second. Exactness is impossible for this contract.

This proof also permits any fixed lookahead window by adding enough intervening jobs. It does not exclude an endpoint-class flag set during arrival, a preemptive comparison schedule, a producer-side index, or a richer shared readout. Such an operation changes premise 2 or 3 and must receive its own construction and access budget. In particular, recognizing the special value 2 cheaply defeats this particular pair; the point is to expose the missing threshold-sensitive operation, not to deny that escape. A general solution must handle every late small threshold with one fixed machine.

A concrete escape handles every fixed short-query cutoff $c$: with ready unary threshold roots, inspect at most $c$ cells at arrival and retain a finite mask of coverage for levels $1,\ldots,c$. Bitwise union of this fixed mask is bounded local work and answers these short queries even behind the stalled FIFO. The machine may depend on fixed $c$, not on the input. This is a prepared-interface control, not free native preparation. It shows why choosing a new constant-size witness after silently allowing such a mask would be invalid. The unresolved extension is one fixed implementation handling unbounded query lengths through paid, input-grown threshold structure.

The right rows are legitimate complete-level inputs, however large their encodings. Their preparation is not free: they must be built and checked during those actual records. The argument grants ready endpoint exports to isolate the consumer’s failure. It assumes no bound on total input size, no sublinear preparation lower bound, and no communication reduction. One fixed contract faces a family of increasing $L$; the machine constants do not grow with $L$. Native recognition, if subsequently obtained, would still transfer to a PEG for the reversed checked language only.

18.3 Compressed preparation: semantic splices and the remaining implementation gate

The producer need not materialize every missing level as a separate record. Maintain ordered missing blocks $[a,b]$ up to the current occupied maximum $H$. Inserting an occupied level $n\le H$ leaves a nonmissing position unchanged, deletes a singleton block, trims one endpoint, or splits $[a,b]$ into $[a,n-1]$ and $[n+1,b]$. If $n>H$, append $[H+1,n-1]$ when nonempty and set the maximum to $n$. These rules hold under arbitrary target order and duplicates; intermediate block count is unbounded even when the final row has one block.

A candidate native representation records, for each block, the occupied gap before it and its missing-run length as unary roots, together with ready absolute endpoint numerals. A target of length $n$ can traverse these runs one unit per actual bit and capture the preceding list through the persistent queue/capsule mechanism already used in section 15. There are useful local charging observations:

• At an interior split, the right length $b-n$ is the unconsumed missing-run cursor. It need not be computed by a long subtraction at the delimiter. The left length has been built during the traversed missing prefix.
• Deleting a singleton merges its preceding occupied gap $g$, one newly occupied position, and its successor gap $e$. Start a fresh accumulator at the immutable root for $e$ and prepend one unit while traversing $g$. The delimiter needs one further unit, not a scan of $e$.
• A maximum extension builds the new missing-run length during the actual extension bits, with a one-bit delay excluding the target endpoint. Running and one-step-lagged position counters offer candidate endpoint exports.

These observations are a producer design, not an admitted native lemma. A complete implementation must exhibit the exact bounded-lookahead block cursor, capsule closing rule, endpoint-root updates in all four deletion/split cases, and the final fixed-block-count gate alongside literal complete-level validation. It must show bounded old-storage observations and allocation at each delimiter, including a zero leading gap and an enormous successor gap. The semantic checker below does not discharge those physical obligations. Even a completed producer would leave the minimum-readout counterexample untouched.

18.4 Evidence, failed routes and decisive continuation

The finite audit checks all 13,312 single-level insertions from width subsets of $[1,10]$, 5,000 random retained-version forks, 16,445 suffix-union memberships, 81 FIFO counterexamples with different fixed service/window constants, 49 alternating-component controls, and 252 fixed-cutoff mask memberships. The FIFO audit explicitly consumes bits of equal numerals and confirms that the head remains unfinished through the allotted service. Its largest comparison exponent is 1,251. Integer sets and tuples supply independent semantic oracles; they are not a native data structure, and the audit does not generate exponentially large literal right inputs.

Three routes have now been separated. Fixed interval slots fail because selected unions can have unbounded component count. Directly reversing the maximum scheduler fails because a late smaller threshold affects early queries. Compressed block splices help preparation but do not pay that consumer debt. None refutes a different persistent representation.

The next decisive target is a threshold-safe persistent minimum receipt for common-maximum suffix rows. Test a preemptive/coarse-threshold interface or an ordinary-input producer index, charging every discovery, root access, classification update and prefix repair. It must answer every actual query before its final delimiter, with fixed degree, radius and finite control, immutable old-top semantics and no free ready handles. First solve this restricted case, or isolate its remaining access obstruction, before claiming a general interval-union construction. The theorem 59 bounded-point construction, general radial frontier and independent-store join question remain intact.

19. A name-sensitive search escapes the FIFO minimum contract

Assessment 189 supplies a native suffix construction, with complete producer and query accounting. Its input-checked exponential name/minimum condition bounds the number of rows that can affect a short query. Capped trie traversal then replaces the FIFO minimum worker. This is theorem 60 on a new restricted class, not an extension to arbitrary interior intervals or a removal of theorem 59’s hole bound without replacement.