Unbounded learned contexts with query-paid codes

12 October 2026. Written native construction 69, extending the lab’s pending-word index. The result concerns a checked serial-reuse language. It is not an independent-store join, a native SAT lower bound, or a claim of external priority.

Structural criterion and payoff

The greedy producer in learned-context construction 68 has more structure than arbitrary overlapping kernels: each produced target has one permanent owning context. A late shorter context cannot acquire an old longer context’s targets. This makes growing disjunction unnecessary. A query may keep only its deepest encountered context, resetting a speculative reader whenever it reaches a deeper mark.

One remaining cost is finding the selected state for that context. We avoid a current directory per context: immutable context codes put all residuals into one current source index. A checked code-length bound lets actual residual symbols pay the code traversal. There is no fixed bound on context count, nesting depth or late ancestor insertions.

The construction uses the exact committed-plus-pending index in section 15, with its native dictionaries, strict persistent queues, unary class clocks and fixed-work old-top compiler. Those are dependencies, not new primitives.

1. Checked ordinary-input language

Fix integers $d,s\ge1$. Put $b=\max(1,\lceil\log_2(d+1)\rceil)$ and fix $c\ge b+2$. These are machine constants. Use right records (-01v,+1w);, left records (-00u,+01v);, and final pins (+00a);(-1q);, with nonempty ordinary binary names. Leading zeros count. Duplicate records and interleaved rows are allowed. Right records precede left records; no decomposition or code is supplied.

Maintain an initially empty ordered list of contexts. On a right record (v,w), choose the earliest existing context prefixing w. If there is none, require $|w|\ge |v|+1$ and create $P$ by removing the last $|v|+1$ bits. Otherwise use the chosen $P$. Write $w=Py$. Require $y\ne\epsilon$, at most $d$ distinct original targets per row, and

$$|\lambda(v)-\lambda(y)|\le s,\qquad |C_P|\le c|y|, \quad \lambda(x)=\lfloor\log_2|x|\rfloor.$$

A context’s immutable code is assigned at creation:

$$C_P=\operatorname{dbl}(v)\,11\,\operatorname{bin}_b(a),$$

where dbl(0)=00, dbl(1)=01, and $a$ is the zero-based slot of this new distinct target in its creator row. Never replace this code with that of a later shorter alias. Its length is $2|v|+2+b$. New contexts satisfy the funding check automatically because $|y|=|v|+1$ and $c\ge b+2$. Existing contexts can fail it. Admission is order-dependent and checked, not existential.

Theorem 69. For every fixed $d,s,c$ above, one deterministic native scaffolding machine recognizes precisely the well-formed formulas that pass this producer and are satisfiable. Degree, radius, finite labels/control and initialization are fixed. Every actual symbol has bounded local work and the last symbol has a ready answer. There is no padding, advice, free preprocessing or EOF service.

The actual encoded length is

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

Explicit phase delimiters, if used, add their actual fixed length. Composite codes do not replace literal names in this measure. The PEG consequence concerns the reversal of this complete checked language.

2. Permanent ownership, including late ancestors

If $i<j$, then $P_i$ cannot prefix $P_j$. Otherwise it would prefix the target that created $P_j$, contradicting creation. Thus among contexts prefixing any word, earlier indices have strictly greater length. Earliest matching context equals deepest matching context, for branching families as well as chains.

A receipt created with tag $j$ has no earlier context prefixing its full target. A later context cannot become its earlier owner; nor can a later context be a deeper prefix of that target, since this would put $P_j$ above a later-created context. Hence the target’s owner is permanent. The domains

$$D_j=\{w:P_j\prec w\text{ and no }i<j\text{ has }P_i\preceq w\}$$

are disjoint and later context creation leaves old receipt membership unchanged. This remains true after any subset of rows is selected and in every retained source version. If a query equals its deepest context, no receipt can denote it: the owning residual would be empty.

The code family is prefix-free: doubled name pairs never contain the aligned terminator 11, and the ordinal suffix has fixed length. Different contexts have different creator-row slots. Consequently $(P_j,y)\mapsto C_jy$ is injective on produced targets. No pointer identity comparison is involved.

This qualifies the review 210 diagnostic. Arbitrary independently populated overlapping kernels require OR and can realize both selected-state collisions. The actual greedy producer excludes a true contribution from any nonowning context. The generic failed wrapper remains a failure; it is not an obstruction to this produced subclass.

3. Ordinary-input production and all delimiter work

Open the ordinary row capsule during v. It exposes at most $d$ immutable original target receipts. Compare each with the full incoming w, with finite mismatch/exhaustion flags; this enforces duplicate and degree checks without context identity tests. Capture the full target FIFO for a new receipt. Missing or malformed names reject through the syntax controller.

While v arrives, build its doubled code FIFO at two appends per bit. The prospective row slot is known at the row leaf; append 11 and its fixed-width ordinal during the intervening fixed syntax. A full row uses a finite excess sentinel and rejects a genuinely new target. A duplicate cannot create a context, because its old context already prefixes it.

Store the context family in a native marked binary dictionary. During w, follow the pre-record context root. At each deeper mark, replace the chosen immutable code handle and reset the candidate residual FIFO, residual class clock and code service state. Only one candidate is live. An empty-context mark initializes it before the first target bit. A mark reached on the current bit starts its residual on the next bit. Following a missing dictionary edge cannot later encounter a deeper mark.

In parallel, use construction 68’s rolling queue: a unary counter of $m+1$ cells, $m=|v|$, retains the last $m+1$ target bits in Q; after initial fill, each new bit expels one oldest bit. Feed each expelled bit immediately into a prospective context insertion capsule, beginning from the current context root. Thus the entire prospective prefix route is paid as w arrives. If no old context matched, the delimiter only checks counter exhaustion, marks the already-reached capsule node with the ready code handle, and closes the established capsule. If an old context matched, discard the prospective insertion. This is the inherited fixed-close capsule operation, not an ordinary path-copying stack unwound at the delimiter. Lookup uses the original root throughout; speculative insertions cannot affect the current record’s choice. Empty prospective prefixes use the root capsule.

For an existing context, run the code-plus-residual service from section 5 below, advancing a unary composite-length class clock instead of a membership reader. Also run the reset residual clock. Compare both with saved copies of the alias class counter using section 15.2: one counter pop per class boundary, finite saturated excess, and only a fixed residual inspection at the delimiter. The funding check is code-cursor exhaustion together with residual-FIFO emptiness, precisely whether the virtual stream is caught up. No logarithm or unbounded arithmetic is a native instruction.

For a new context, the residual has length $m+1$, and the composite length is exactly $3m+3+b$. Prepare that class clock prospectively during v, with $3+b$ initial ticks and three ticks per alias bit. The alias and prospective composite clocks advance together; their class difference is bounded by a fixed constant and maintained by finite increments/decrements on boundary events. No final traversal is required. The first residual span is at most one. Store the composite word as a fixed tuple of FIFO pieces (code,Q), with an ordinary finite-state piece reader; concatenation does not copy either word.

An admitted existing-context receipt similarly stores (code,residual), its exact composite class offset, and the full target receipt used for degree checks. At most $d$ receipts enter a row. All resets discard a bounded tuple of roots, not the objects behind them. All prospective, discarded and duplicate-processing work is charged to the literal symbols that performed it.

4. One current selected index

For $z=C_jy$, the producer guarantees

$$|y|\le |z|\le(c+1)|y|.$$

Hence the stored-word theorem applies with the fixed span

$$S=s+\lceil\log_2(c+1)\rceil+1.$$

Each source u has one section 15 index for the composite words, with committed tries and bounded pending tuples in its length buckets. Actual u bits open the current source capsule. Actual v bits service the fixed $S$-window before the row receipts are revealed. At the delimiter, at most $d$ ready composite receipts enter their serviced pending buckets via finite offsets. Closing the outer capsule is fixed work. Missing rows add nothing. No context route is walked, and no historical context marker is treated as a current selected-state root.

The inherited service invariant installs old pending work into the current committed root, preserving exact answers while jobs remain unfinished. All stored FIFO pieces are immutable. After any completed selection prefix, the source predicate is exactly

$$Z_u=\{C_jy:\exists v\ (R(u,v)\land S(v,P_jy)),\ P_jy\in D_j\}.$$

Retained versions satisfy the same invariant for their own selection prefixes. This is serial reuse inside the prepared store; no arbitrary external version handle or independent-store merge is granted.

5. Query-paid decoding with one speculative reader

The positive pin opens the current source-global index. Follow the frozen context dictionary as the ordinary target pin arrives. At each deeper mark, discard the previous virtual reader and reset from that same current source root with the new immutable code. No state selected by the old context is needed. Section 2 proves this replacement exact for every possible continuation.

After a mark, enqueue each actual residual bit and execute up to $c+1$ virtual-symbol steps: emit the code first, then the residual FIFO in order. Feed that stream into the section 15 current/ahead bucket reader, including its unary class clock, replay and pending comparisons. Each virtual step has the inherited fixed cost, so a fixed number per actual symbol is allowed.

If the code length is $L$ and $n$ actual residual bits have arrived, the unprocessed backlog is

$$B_n=\max(0,L-cn).$$

Indeed $B_0=L$; enqueue one bit and service up to $c+1$, giving $B_{n+1}=\max(0,B_n-c)$. Empty service slots are idle. Once caught up, the virtual reader has consumed exactly the code followed by all residual bits, in order. No guessed final length is used.

At query termination, an unfinished stream yields false: every produced receipt with this owning context and this residual length would violate $L\le cn$. A completed stream yields the exact membership result in $Z_u$. No context or an empty owning residual also yields false. Complement membership to obtain the Horn SAT answer. The final syntax only reads flags; it drains no queue. A deeper mark reached on a bit discards any old reader work on that bit and starts the new residual on the next bit, still with fixed overhead.

This proves the answer without reading all contexts, migrating child kernels, or delaying the first residual bit. The stronger readout uses local negative tests and exact committed-plus-pending membership, not only positive path existence.

6. Native charging and an unbounded witness

The number of live workers, FIFO pieces, row comparisons and length-window slots depends only on $d,s,c$. Each record has a fixed number of simultaneous dictionary capsules; nesting is not proportional to context depth. Dictionary paths and code observations are traversed only by the actual-symbol schedules above. Fixed initialization, finite labels/control, old-top update semantics, bounded degree and fixed radius follow through the established simultaneous-record compiler. It uses $N+1$ physical nodes, $O_{d,s,c}(N)$ logical allocation including discarded work and retained history, and $O_{d,s,c}(N\log(N+2))$ bits under external pointer serialization. These storage bounds alone do not prove access; sections 3–5 supply its deadlines. No address, identity, metadata, timing or control-flow side channel encodes the predicate.

For arbitrarily large $h\le2^r$, take distinct aliases of length $r\ge1$ in any order and targets

$$w_i=0^{L+h-i}\,1t_i,\quad |t_i|=r,\quad 0\le i<h.$$

Each newly created context is $0^{L+h-i}$; its 1 prevents all older, longer contexts from matching. Thus there are $h$ nested contexts created in decreasing depth, each with residual length $r+1$. Degree one, span one and $c\ge b+2$ suffice. The stem $L$ is arbitrary. Every source selection subset and ordinary final query is covered. No shared alias/target route, context-count bound or supplied handles are present.

The class still excludes short residuals attached to a context with a much longer immutable creator code. Replacing that code by a later shorter representative would change old keys and their current selected predicates; it is not a free repair. The next decisive test is to remove this funding guard with a paid stable recoding or a different current-readout mechanism, beginning with one old long creator followed by many short aliases. Clipped-cone interval activation and independent-store joins remain separate frontiers.

Entry 129’s imported growing-alphabet state/port bounds retain their exact matching or positive-path interface hypotheses. This construction supplies neither such summary nor a contrary language lower bound. Replay slices, affine-fragment joins, persistent causal algebra and unary coherent cubical algebra remain controls with their existing resource qualifications.

Evidence and assurance

The independent finite audit constructs actual right-record histories, compares every retained selected version against literal targets, and separately tests the backlog recurrence. Its host maps, strings and counters are semantic oracles, not a native implementation. The assessment 211 review records adversarial review, checks and remaining scope. The new written argument is permanent ownership plus stable codes with query-paid decoding; the underlying native index and compiler are reused. Root claim admission and external novelty remain separate.

Successor: construction 70 removes the separate code-funding guard by assigning immutable codes per context and residual length class. The theorem and evidence above retain their original scope.