Bounded omissions from input-paid scans

12 October 2026. Written native construction 75 for every fixed omission bound. This extends the Lab’s persistent dictionaries, strict queues and pending-reader schedule. No root-ledger admission or external priority claim.

Construction 76 subsequently combines independently prepared stores under bounded-fan-in or routed-readout contracts. The result here remains the local store construction.

Result and why the representation works

A row may be large, and its omitted targets may have long unrelated names. Nevertheless, if the final row misses only a fixed number of globally observed targets, its own positive records can pay for discovering those exceptions. Use each later record for that row to inspect one target in global birth order. Keep the inspected-prefix exceptions explicitly. The scan keeps pace with the row’s distinct members, so only a fixed-size global tail remains uninspected when the final omission gate holds.

The crucial second step is access. The producer assigns short exact codes to the exceptions and scan boundaries that are currently retained. Comparing a row’s boundary code with a bounded global birth window locates its unscanned tail. Later short aliases can then intersect omission sets using short codes; they never compare the long birth indices or decode polynomial roots.

For example, suppose a final row misses at most two targets. Its processed part lags by at most its one pending target. Its scanned prefix therefore leaves at most three global targets unscanned. A window containing the last four birth targets includes the scan boundary and every later target. Three kinds of finite data suffice: missing targets already scanned, present targets not yet scanned, and the pending target. Code equality reconstructs the exact two omissions.

Criterion. For each fixed omission bound, dense final rows provide enough actual records for a row-local scan to keep pace with their distinct membership. Stable birth order, bounded-tail recovery and reference-counted short exception codes turn that preparation into bounded-local-cost serial reuse. The final density gate is checked, not promised. Intermediate rows may have arbitrarily many omissions.

This completes the charged two-omission interface left open by the primary-proof review. It also covers every fixed larger omission bound. Common widths remain, but their ratio is unrestricted; independently prepared stores are not joined.

1. Checked language and native contract

Fix an integer $k\ge1$. Use the right-first Horn syntax of construction 74: right records (-01v,+1w);, left records (-00u,+01v);, and late pins (+00a);(-1q);, with its fixed phase delimiters. Require at least one right record. Actual nonempty binary names determine a common alias width $\ell$ and common right-target width $n$. Leading zeros count. Check all later widths. No comparison between $\ell$ and $n$ is required.

Let $X_v$ be the distinct right targets for observed alias $v$, and $U=\bigcup_vX_v$. At the right boundary require

$$|U|-|X_v|\le k\qquad\text{for every observed row }v.$$

An absent alias denotes EMPTY and is not another row subject to the gate. Source and pin lengths remain unrestricted beyond syntax. A well-formed wrong-width or off-support target pin gives false product membership, hence SAT; it is not a failure of the right-factor width gate.

Theorem 75. For every fixed $k$, one deterministic native scaffolding automaton recognizes exactly the well-formed formulas satisfying these gates that are satisfiable. Its degree, observation radius, labels, finite control and initialization are fixed. It uses immutable old-top updates, bounded work and allocation per actual input symbol, and final-symbol output.

For actual encoded length

$$N=\sum_R(9+|v|+|w|)+\sum_L(10+|u|+|v|)+11+|a|+|q|,$$

plus the actual fixed phase delimiters, logical work, old-storage observations and retained records are $O_k(N)$. The inherited simultaneous-record compiler gives $N+1$ physical scaffold nodes. Explicit pointer serialization uses $O_k(N\log(N+2))$ bits. Native recognition gives a PEG for the reversal of this entire checked language.

The family is indexed only by fixed $k$, not by input size. No supplied birth order, exception list, decomposition, ready handle, padding, advice, free preprocessing or EOF service is used. Codes are compared by their actual bits, not by identity, address, timing or allocation metadata.

2. Exact delayed row state

Assign each distinct target a birth index $1,2,\ldots,g$ when it first appears globally. Keep a literal global trie whose leaves contain those indices, and an index dictionary whose leaves contain the actual target words. Both are built from ordinary right records. Indices and counters use $n+1$ bits; since $g\le2^n$, this includes a speculative successor.

A row header retains:

• a processed literal set $R$ and one pending target $p$, with its literal word and birth index;
• a scan boundary $i$, meaning that birth positions $1$ through $i$ have been inspected;
• literal tries $H=U_{\le i}\setminus R$ and $P=R\setminus U_{\le i}$, with their cardinalities;
• its full degree $c=|R\cup\{p\}|$ and the short-code descriptor described below.

Thus the actual row is always $X=R\cup\{p\}$. A new row before its first target has no pending target and has $R=H=P=\varnothing$, $i=c=0$. Here $U_{\le i}$ denotes the first $i$ births, a stable set even when later support grows. No old row changes its interpretation when another row introduces a target.

During a later record for this row, before incorporating the incoming target, do the following work using already retained words:

1. Insert the old pending target into $R$. If its birth index is at most $i$, remove it from $H$; otherwise insert it into $P$. Duplicate insertions have no effect. The resulting processed set is exactly the old full row, of degree $d=c_{\mathrm{old}}$.
2. If $i<g_{\mathrm{before}}$, retrieve birth target $i+1$ through the index dictionary. If it belongs to the updated $R$, remove it from $P$; otherwise insert it into $H$. Increase $i$ by one and retain that target as the boundary word. If the scan is caught up, leave the boundary unchanged.
3. Prepare the descriptor for these now fixed $R,H,P,i$. The incoming actual target becomes the new pending target at its endpoint.

All insertions, removals and membership decisions are exact literal operations. In particular $P$ is necessary: a target beyond the boundary may already belong to the processed row. Treating every unscanned target as absent would be wrong.

3. The scan invariant and bounded-tail theorem

Invariant. Every completed row header satisfies $i\ge|R|$.

Proof. Initially both values are zero. Processing the old pending target increases $|R|$ by at most one. The old boundary was at least the old processed size. If a scan step is possible, increasing the boundary by one restores the inequality. If no step is possible, the boundary is $g_{\mathrm{before}}$, which is at least the size of the updated processed row. Installing the new pending target does not change $R$ or $i$. This also covers duplicate records and a new alias encountered after many global births.

Set $K=k+1$. On a row satisfying the final gate, $|X|-|R|\le1$, and therefore

$$g-i\le g-|R|\le k+1=K,\qquad |H|\le K,\qquad |P|\le K.$$

The bound on $H$ follows from $H\subseteq U\setminus R$. The bound on $P$ follows because $P$ lies in the unscanned tail, whose size is $g-i$. These are final guarantees only; the maintained tries and counts may be large earlier.

Keep a global window $W$ of the last $K+1=k+2$ birth targets, or all births if fewer exist. If $i>0$ and $g-i\le K$, the boundary target at position $i$ occurs in $W$. If $i=0$, the inequality implies $g\le K$, and the entire support occurs in $W$. A reserved zero-boundary flag covers this case.

Consequently the unscanned tail $T_i$ is exactly the window suffix after the matching boundary target, or the whole window for boundary zero. The row’s exact omissions are

$$U\setminus X=\bigl(H\cup(T_i\setminus P)\bigr)\setminus\{p\}. \tag{1}$$

Indeed the inspected prefix contributes exactly $H$, and the unscanned part contributes its targets not already in $R$, namely $T_i\setminus P$. Removing the pending target converts the processed row to the full row. This proves the formula without polynomial arithmetic or a scan at the right boundary.

4. Short descriptors with paid reference ownership

A row descriptor is eligible when both ready counts satisfy $|H|,|P|\le K$. For eligible rows it contains their at most $K$ literal words and exact codes in each list. For an ineligible row it contains no $H/P$ lists and an ineligible flag. Every row additionally owns one boundary reference when $i>0$ and one pending-target reference. Each window entry owns a reference. The final gate guarantees that every frozen row descriptor is eligible; no final conversion is performed.

Use a persistent literal-name dictionary for the active reference pool. Each leaf contains a positive unary reference count and a binary code of common length

$$m=\min(\ell,n)+d_k,$$

where $d_k$ is a fixed constant chosen with $2^{d_k}\ge8K+16$. A symbolic FULL binary free-code trie supplies unused codes without enumeration. Allocate, release and compare codes by paid length-$m$ paths and actual bits. Dictionary keys are the literal length-$n$ target names. All copies of one active name receive the same code; different active names receive different codes.

There are at most $2^\ell$ observed aliases. Stable row descriptors use at most $(2K+2)2^\ell$ references. The window uses at most $K+1$, and at most one evicted window reference awaits retirement. While rebuilding one row, temporarily retain its old descriptor and at most $2K+1$ new list/boundary references. Thus at most

$$(2K+2)2^\ell+3K+3$$

references suffice before installing the incoming pending target. This reference bound also bounds distinct live names. Independently, every pool key is a literal length-$n$ target, so there are at most $2^n$ distinct keys, including the incoming target. If $\ell\le n$, the reference bound and the fixed surplus $2^{d_k}$ provide spare codes. If $n<\ell$, the literal-universe bound provides spare codes in $2^{n+d_k}$ slots. Thus the minimum-width code space has ample capacity in both cases, including a reserved candidate. There is no full-pool emergency case.

When a row is revisited, perform its ready reference changes sequentially on the evolving current dictionary root. Add the new list/boundary references, then remove its old list/boundary/pending references. An equal name can temporarily have multiple references. Enumerate $H,P$ only when their counts are at most $K$; a literal trie with at most $K$ leaves has at most $O(Kn)$ nonempty path nodes. Dirty-to-eligible transitions therefore have a paid bounded enumeration. No old ineligible row is scanned merely because some other row changed.

This sequencing matters. Independent stale writeback paths to overlapping keys would not implement a joint transaction. Here each completed point update supplies the root for the next point update, using the inherited coherent path-capsule closure. All those keys are old ready words. The incoming target is handled only after these updates, as described next.

Code recycling cannot change retained snapshots: each version retains its coordinated row descriptors, pool and window. Only active references in one frozen right-store version are compared during left selection. No code equivalence across independently prepared stores is asserted.

5. Work during one actual target and its endpoint

Use the Lab’s strict persistent queues, coherent trie paths and bounded simultaneous-record compiler, also used in constructions 71–74. Point insertion/deletion, indexed lookup, literal membership, counter scans and bounded-leaf enumeration use $O(n+1)$ local work per operation; each has fixed-degree records and bounded local child/head observations. Empty branches are pruned, so enumeration does not walk through an old deleted population.

The actual alias retrieves the old row header and opens its outer writeback capsule. It builds only alias-sized header/ruler data during the alias. New rows share the ready immutable length-$(n+1)$ zero streams initialized by the first target; any remaining target-width setup belongs to the paid target work below. The subsequent target supplies $n$ actual symbols of service. At its start all old-row and global roots, the old pending word and index, and the previous window-retirement word are ready.

The early worker performs the following fixed-size sequence:

• Retire the preceding window’s one deferred reference, if any.
• Process the old pending insertion, advance the birth scan once, and finish the ready $H/P$ counts.
• Enumerate eligible exception lists and perform their sequential pool updates.
• Prepare a spare incoming code and the corresponding free-pool variant, and retain the resulting pool root.
• Prepare global count/index-successor paths and degree-histogram/minimum candidates.

There are only $O_k(1)$ operations on length-$n$ words/counters or length-$m$ codes. Since $m\le n+d_k$ and $n\ge1$, a fixed constant $b_k$ bounds this early work, including returns, observations and allocation, by $b_k(n+1)$. Fixed acceleration completes it in an initial fraction of the target. Finitely many small widths are absorbed by a larger fixed service constant, not by padding or an input-dependent machine.

Meanwhile a strict FIFO retains the incoming actual target bits. After early work finishes, accelerated cursors consume that same buffered stream in parallel to:

• test membership in the updated processed row $R$;
• traverse the final early-work pool root;
• traverse and prepare the global literal target trie;
• retain the complete new pending word.

Choose their fixed rate greater than the input arrival rate and large enough to catch up strictly before the last bit for nonsmall widths. Thereafter each arriving bit is processed in its own bounded batch. The FIFO is persistent and forward-readable; no unpaid reversal is hidden. The current target never traverses a root that is subsequently overwritten by another early transaction.

At the endpoint, global membership selects the old birth index or the already prepared successor index. If globally new, close the prepared index-dictionary path with the completed target word and append its word/code pair to the constant-size window. A dropped window entry becomes the sole deferred retirement reference for the next ordinary right record. Its extra reference may remain after the last record; neither query correctness nor capacity requires EOF cleanup.

The current pool lookup selects an existing code or the prepared fresh candidate. Its leaf reference count increases by one for the new pending target and by one more exactly when a new global birth enters the window. Those unary unit changes and all payload choices are bounded operations. The free-pool choice and coherent path closure are ready. No length-$n$ lookup begins at the endpoint.

The incoming membership flag selects degree $d$ or $d+1$. Since $d=c_{\mathrm{old}}$, the old histogram is unchanged or moves one row from $d$ to $d+1$, exactly as in construction 74. Its prepared candidates use ready old count streams. If the updated row was the sole minimum-degree row, the new minimum is $d+1$; otherwise it stays unchanged. A newly observed alias has degree one and supplies the corresponding prepared insertion/minimum case. All possible comparisons with the unchanged or incremented global support count are prepared during the target. Use threshold $\max(0,g-k)$, with an underflow flag for $g<k$, so small supports need no unsigned negative counter. Thus the final gate $\min_v|X_v|\ge g-k$ has an up-to-date Boolean flag after every record.

Commit the row header, outer row path, pool/free roots, global literal/index roots, counts, histogram, window and deferred-retirement field as one fixed tuple. At the final right delimiter, check the already ready gate and freeze that tuple. A last support birth requires no visits to other rows: their prefix sets and active references keep their meanings, while formula (1) uses the final global window.

6. First record, malformed input and retained storage

The first alias builds its width ruler. During the first target, advance a cursor in that saved ruler once per actual target bit until the ruler is exhausted. Each successful advance appends one zero to the initial code and opens one level of its free-pool path. Exactly $\min(\ell,n)$ zeros have been built when the target ends. Append the fixed $d_k$ zero suffix in the delimiter’s fixed batch and close the implicit free-code capsule with $0^m$ removed. This builds the code and its free-pool path from actual symbols, without knowing $n$ in advance or enumerating free slots. The completed code is attached to the already prepared first pool and window payloads in that same bounded endpoint batch.

The first target initializes $R=H=P=\varnothing$, $i=0$, and pending word $p=w$. Its bits build the global literal trie, the pool path, the target word FIFO, the width ruler, and explicit count/index-one and zero-cursor streams. The index-one dictionary path is built while the target arrives; its completed word payload is attached at capsule closure. Set $g=c=\min c=1$. The first code has reference count two, for pending and the singleton birth window. There is no deferred retirement. The histogram has its one ready degree-one leaf. No scan or unknown-width reconstruction is required.

Later records use the saved width rulers and minimum-width code ruler. Syntax and width violations set a permanent rejecting flag; unfinished invalid-input speculation need not be made reusable. Temporary failure of the final density gate does not permanently reject, since later positive incidences can repair it.

Every candidate, discarded speculative path and retained historical version counts toward storage. Each record performs a fixed number of operations linear in its actual target length, and each alias/pin performs its own literal routing. This gives the stated $O_k(N)$ total. No proof step amortizes unpaid work over a future record that might not occur.

7. Short-alias composition and immediate readout

After freezing, every eligible descriptor and every window name owns an active pool reference. Comparing its $m$ actual code bits is exact equality of literal targets. Boundary equality finds the proper window suffix in $O_k(m)$ work. Formula (1) then uses only a constant number of list comparisons; it returns at most $k$ omission entries, each retaining both its short code and its original literal-word pointer. No long index or target-name scan is needed in this operation.

Represent a committed nonempty selected union by its omission list $B$ relative to $U$. Adjoining a row with omission list $H_X$ replaces it by

$$B\gets B\cap H_X.$$

Use a separate EMPTY state before any observed row has been selected. An absent alias contributes EMPTY and is skipped. These exact operations cost $O_k(m)=O_k(\ell)$ local work and allocation; the constant $d_k$ is paid because $\ell\ge1$. The strict-extension predicate from review 220 is consequently implemented by checking whether the intersection loses an entry.

A source capsule keeps the committed state and one pending row reference. During the next actual alias for that source, extract the old pending row’s omissions and complete its intersection, while the new ordinary alias lookup proceeds. At the alias endpoint install the newly looked-up row as pending. The service constant depends only on $k$. A source never selected again retains its pending row without a forced completion.

An immediate final pin uses exact literal readers. A committed nonempty union accepts a target precisely when it belongs to the global literal support and differs from each of its at most $k$ omitted words. The pending row accepts precisely when its processed trie $R$ or pending literal word $p$ accepts. OR these two contributions, then complement for pinned Horn SAT. EMPTY contributes false. A fixed batch of at most $k$ equality streams and the support/row readers processes each actual query symbol and checks its endpoint. The positive source pin pays retrieval of this capsule. Short, long and off-support queries are handled without completing an omission-extraction job at EOF.

This produces both the charged extension interface and a direct omission-list consumer. It does not rely on the semantic three-row bound as a substitute for access accounting.

8. Scope, evidence and the remaining decisive test

The one-omission theorem 74 remains valid; theorem 75 enlarges its omission gate to every fixed $k$ and removes its one-sided funding condition. Alias names share one width and target names another; the two widths have no required ratio. Support can be arbitrarily sparse and can grow on the last right record. Intermediate omissions, record interleaving, distinct target count, row count and selection count are unbounded. The proof avoids polynomial field operations and long-name decoding during short selection.

The independent finite audit checks literal semantics, code-only tail recovery, reference ownership, recycling, dirty-descriptor recovery, retained snapshots and immediate negative queries. It uses host sets, maps and integers as oracles; it is not a native execution or timing measurement. The all-size resource claim is the written schedule above. Assessment 222 records review and validation.

Replay still pays each traversal. Affine-fragment joins retain their coordinate hypotheses. Persistent causal sharing preserves histories but does not alone supply the scan, pool ownership or strict deadline. Unary coherent algebra does not itself supply this branching exception interface. Imported entry 129 retains its growing alphabet and conditional state/port lower bounds. This is a native positive subclass, not a general SAT/scaffold lower bound or an independent-store joining theorem.

Next decisive target: test composition between two independently prepared stores with the same literal support and fixed final omissions, but independent birth orders and recyclable code assignments. Start with late selection across both stores and immediate ordinary-name negative pins. Either construct a paid common equality interface, including initialization, routing and any reconciliation, or exhibit an exact charged obstruction. Do not assume equal local codes denote equal names or supply ready join handles. Variable-width names remain a separate frontier.