Context codes at the scale of future questions

12 October 2026. Written native construction 70. A length-class refinement removes construction 69’s separate code-funding check. The result remains a checked serial-reuse subclass with bounded right-row degree and comparable alias/residual length classes.

Why a long creator should not govern a short question

Suppose the first row learns a shared prefix using a very long alias. A later row uses the same prefix with a short ending and a short alias. Construction 69 gives the whole context its first creator’s code. The later short query may have insufficient time to read that code.

Instead, give a context a separate immutable code for each residual length class. A short ending uses the code first created by an ending of comparable length. Codes never change and old selected answers never migrate. A current reader and one reader prepared ahead of time suffice even though there can be unboundedly many contexts and classes.

The main point is a reuse criterion: permanent semantic ownership plus scale-compatible immutable names permits current answers to share one persistent index. Ownership limits the simultaneously relevant contexts; the scale bound pays both delayed name decoding and prefix replay. This note proves the producer and deadlines, rather than inferring them from compact storage.

1. Exact checked language

Fix $d,s\ge1$, independent of the input. Use the ordinary right-first Horn syntax of construction 69: right records (-01v,+1w);, left records (-00u,+01v);, and final pins (+00a);(-1q);. All names are nonempty binary words, leading zeros count, and duplicates and arbitrary row interleaving are allowed.

Learn contexts by the same greedy rule. Choose the earliest existing context prefixing the current target. If none exists, require $|w|\ge |v|+1$ and create a context by removing the last $|v|+1$ target bits. Write $w=P_jy$. Require $y\ne\epsilon$, at most $d$ distinct original targets in each right row, and

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

There is no code-length check, no fixed context count and no supplied routing or decomposition. Admission still depends on the actual right-record order. These are exactly construction 69’s structural checks after deleting its code-funding guard.

Theorem 70. For each fixed $d,s$, one deterministic native scaffolding machine recognizes exactly the well-formed formulas passing these checks that are satisfiable. Its degree, radius, finite labels/control and initialization are fixed. It performs bounded local work per actual symbol and answers by the final symbol, without padding, advice, uncharged preparation or EOF work.

The actual length remains

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

plus any explicit fixed phase delimiters. Internal codes do not replace names in this formula. The native-to-PEG consequence is a PEG for the reversal of this complete checked language.

The reused machinery is section 15’s exact committed-plus-pending index, strict persistent FIFOs, unary doubling clocks, native capsule dictionaries and their fixed-work old-top compiler. No new random-access primitive is assumed.

2. Stable ownership and immutable class codes

Greedy creation ensures that an older context never prefixes a newly created one. Thus the earliest context matching a target is its deepest matching context. Every produced target has that same owner forever, including after later shorter contexts appear. This is the permanent-ownership argument; it applies to branching families and every retained selected version. Nonowning contexts cannot contribute true membership for that target.

For each pair $(j,h)$ first encountered in an admitted right record, where $h=\lambda(y)$, assign

$$C_{j,h}=\operatorname{dbl}(v)\,11\,\operatorname{bin}_b(t), \qquad b=\max(1,\lceil\log_2(d+1)\rceil).$$

Here dbl(0)=00, dbl(1)=01, and $t$ is the original target’s zero-based first-occurrence slot in its creator row. A repeated target cannot create a new pair: owner and residual length are permanent. One row slot creates at most one pair. Hence all assigned codes are distinct and prefix-free, even across contexts and classes. Codes are immutable once assigned.

Let

$$A=2^{s+2}+b+2,\qquad S=s+\lceil\log_2(A+1)\rceil+1.$$

The creator satisfies $|v|<2^{h+s+1}$, so

$$|C_{j,h}|=2|v|+2+b\le A2^h.$$

Every residual using this same pair has $|y|\ge2^h$. Therefore its composite key $z=C_{j,h}y$ satisfies

$$|y|\le|z|\le(A+1)|y|,\qquad |\lambda(v)-\lambda(z)|\le S.$$

This is a consequence of the original class-span gate, not an added admission test. Distinct produced targets have distinct composite keys. A context’s directory of codes can have holes: an absent class is different from the end of its directory.

3. Two class readers meet every query deadline

First fix one context and let $n$ be the number of residual bits already read. A frozen one-child directory contains slots for classes zero through its highest encountered class, with absent-code markers in unused slots. An implicit blank suffix follows the end. Advancing one slot is bounded local work, not an array lookup. The query retains the current source-global index root independently of this directory.

At $n=1$, initialize the class-zero virtual reader on $C_{j,0}$ followed by the first residual bit. Its code has at most $A$ bits, so this is fixed work. An absent code gives an exact false reader. Maintain a persistent FIFO of all actual residual bits.

At a boundary $n=M=2^h$, the current class-$h$ reader is caught up. Start an ahead class-$(h+1)$ reader from the same saved current source root. Give it a fixed tuple of streams: its code, a snapshot of the first $M$ residual bits, and a fresh FIFO for subsequent arrivals. A snapshot copies a bounded root tuple; replay still consumes every bit at a charged rate.

During each of the next $M$ actual bits, update the current reader with that bit and service the ahead reader for up to

$$Q=2A+4$$

virtual symbols, in code-then-residual order. By the next boundary the ahead reader owes at most

$$|C_{j,h+1}|+2M\le(2A+2)M$$

symbols. More precisely, its initial backlog is at most $(2A+1)M$; one new residual bit arrives per tick and $Q$ service slots leave more than enough net capacity. Greedy service therefore catches up by $n=2M$. Promote it, discard the old reader and prepare the next class. If input ends earlier, only the already-caught-up current reader answers; speculative ahead work is discarded and charged.

Each virtual reader is itself section 15’s fixed current/ahead bucket reader, including exact pending comparisons. Composing these two fixed-width schedules multiplies their constants, not their number of live readers. Missing code slots need no virtual work; after directory exhaustion all higher slots are absent. There is no scan across earlier codes and no independent full-residual replay for every historical epoch.

Now restore context discovery. Follow the frozen context trie on the ordinary query. At each deeper marked context, replace the code-directory handle, reset the residual FIFO and the two class readers, and retain the same current source root. The next actual bit starts the new residual. Stable ownership makes replacement exact for every extension. No mark, or termination exactly at the deepest mark, gives false membership. Complement the ready membership bit for Horn satisfiability. The final syntax performs no queue drain.

4. Build the directories and receipts from ordinary right input

The producer must discover both context and length class without a delimiter-time traversal. The following workers operate at fixed rates simultaneously.

Rows and literal equality. Actual alias bits open the ordinary row capsule and build the alias class clock, a unary length counter, and the doubled alias FIFO. At the row leaf, the finite target count supplies the prospective slot ordinal. Append its terminator and fixed-width ordinal during the intervening syntax. Compare the arriving full target with the at-most-$d$ original target receipts to detect duplicates and enforce degree. Equality never uses pointer identities.

Context lookup and update access. Follow the pre-record marked context trie using a native path capsule. At a mark, retain its capsule snapshot and code-directory root; continuing the lookup does not mutate that root. A deeper mark replaces the saved update capsule and resets residual workers. Thus the producer has an already-paid update path to the finally chosen context, rather than obtaining a context spelling at the end and looking it up again. Context depth does not increase the number of suspended capsules.

Existing context, residual directory. After the chosen mark, the unary residual clock advances the one-child class-directory capsule at doubling boundaries. A current slot and one ahead slot are explicit. Missing slots through the visited class are represented by blank records, with only fixed work at each boundary. For an occupied class, run section 3’s current/ahead code-plus-residual streams into class clocks rather than membership readers. Saved copies of the alias class counter compare the resulting composite class by the section 15.2 pop-at-boundaries procedure. The current occupied slot’s exact composite offset is ready whenever the record ends.

Prospective new class. An empty slot may need a code made from this record’s alias. Its length is $B=2|v|+2+b$. During v, prepare a snapshot of the unary length clock at $B$ and its finite class difference from $|v|$. On reaching a context mark, reset to that snapshot. Each residual bit advances it once. It therefore measures $B+n$ and maintains its class offset without replay. Initial difference is bounded solely by $b$; later class boundaries update a finite offset, saturated outside the fixed permitted range. The separately checked residual span implies the composite offset is within $S$ on admitted records. This prospective clock is independent of the occupied-code readers.

At the right delimiter, check the residual span and row degree. If the current class slot is absent, install the ready candidate code there; otherwise retain its existing immutable code. The slot and context capsules have already reached their destinations and close by the inherited bounded capsule operations. The fixed tuple (code,residual FIFO) is a ready composite-word receipt with the computed finite class offset. Neither concatenation nor a path unwind occurs at the delimiter. Discard speculative ahead updates beyond the selected slot, preserving any existing suffix of the directory.

New context. In parallel, construction 68’s rolling queue keeps the final $m+1$ target bits, $m=|v|$. Every expelled bit advances a prospective context insertion capsule immediately. If no old context matches, its ready prefix becomes the new mark. The residual length is $m+1$; a unary clock during the rolling queue’s initial fill prepares its class directory, including necessary blank slots, and its final slot receives this record’s candidate code. The composite length is $3m+3+b$, prepared during v with three ticks per bit and fixed initialization. The delimiter publishes only ready fixed-size descriptors. If an old context matched instead, all prospective new-context work is discarded and remains charged.

The residual span gate uses the reset ordinary residual clock and saved alias class counter, so an invalid record rejects even if its code was already present or it is a duplicate. An admitted new context has span at most one. Empty right blocks give no contexts or receipts. Malformed syntax rejects. All context/class changes occur during the right block; after it, these dictionaries are frozen. There are no selected source states to migrate during this preparation phase.

5. Reuse one current source index without recoding

A frozen row contains at most $d$ composite receipts with offsets in $[-S,S]$. During each left record, actual u bits open the current source index; actual v bits service section 15’s fixed $S$-window while looking up the row. At the delimiter, the ready receipts enter serviced pending slots. Neither their context nor their code is looked up again. The index’s logical set is committed entries union bounded pending entries, including during unfinished installation.

After every completed selection prefix,

$$Z_u=\{C_{j,\lambda(y)}y:\exists v\ (R(u,v)\land S(v,P_jy)),\ P_jy\text{ has owner }j\}.$$

The injection and section 3 query schedule give exact membership in the original selected target union. Repeated selection is idempotent. Retained source roots preserve their own selection-prefix answers. This is charged serial reuse inside the prepared store, not arbitrary access to external historical handles or a join of independently allocated stores.

All old-storage observations, pointer routing, context/class preparation, pending service, code consumption, prefix replay and discarded speculative work fit a fixed number of operations per actual input symbol. Queue snapshots are roots, not uncharged word copies. The number of simultaneous workers and capsule interfaces depends only on $d,s$. The established old-top compiler yields fixed degree/radius/labels/control and $N+1$ physical nodes, with $O_{d,s}(N)$ logical allocation including retained history and $O_{d,s}(N\log(N+2))$ external pointer bits. No identity, address, metadata, timing or control-flow side channel provides answers. Storage size is not used as a substitute for the access schedule.

6. Strict extension and remaining structural boundary

Take one creator alias of length $m$, target $P0^{m+1}$, and a distinct one-bit alias with target P1, for fixed nonempty P. Both rows have degree one and residual span at most one. The first learns exactly P; the second uses it. For any fixed construction 69 funding constant $c$, choosing $2m+2+b>c$ makes that construction reject the second row. Here class zero receives a new short code, so both rows pass. Queries for either target and every selection subset are covered. No dummy input or extra record is added.

The unbounded descending-context family from construction 69 remains admitted. Together these show removal of the funding guard while retaining unbounded context diversity, late ancestors and arbitrary ordinary aliases within the residual span.

This does not yet cover unbounded target degree per row or arbitrary alias/residual length ratios. The next decisive test is to restore sibling-closed clipped-cone rows using these class-specific codes: can an ordinary-input completeness producer and a checked mixed-region budget replace the fixed receipt tuple, while preserving code routing and pending readout? Code existence alone does not establish closure of that richer representation under selection. Independent-store joins remain separate.

There is a concrete additional barrier to dropping degree while retaining these codes unchanged. Use one alias 0 and targets $P_i00$, where arbitrarily many distinct $P_i$ have the same length. Each creates its own context with a class-one residual and span one. Globally distinct binary codes of length at most $2A$ form a finite set; prefix-free codes have cardinality at most $2^{2A}$. Thus no fixed $A$ can label every such context/class pair in this interface. The current ordinal width grows with the degree bound for exactly this reason. An extension must aggregate contributions or charge a different route, possibly to the literal query prefix. This counting argument rules out the unchanged bounded-code interface only, not a native language recognizer.

Entry 129 remains an imported matching/positive-path interface bound over its growing alphabet. This construction uses stronger exact negative readout and supplies no matching-summary extraction or native-language lower bound. Replay slices still pay every replay; affine-fragment joins do not grant coordinate conversion; persistent causal algebra preserves history without paying access; unary coherent cubical algebra does not supply a growing-branch join.

Evidence and contribution

Subsequent work. The geometry test in assessment 213 shows that creation-order codes can fragment a complete literal cone, so the mixed-region budget does not transfer automatically. Frozen-support construction 71 supplies a separate support-first subclass with unbounded row degree. It does not remove this construction’s degree restriction or establish inclusion between the two checked languages.

The independent finite audit checks ordinary producer histories, class codes, retained versions, delayed virtual streams and the strict-extension witness. Host strings/maps/counters are semantic oracles, not native instructions. Assessment 212 records independent adversarial review and validation.

This is a written extension of the lab’s immutable-code and pending-window constructions. The additional mechanism is permanent ownership refined by residual scale, plus a second fixed-width lookahead schedule. Confidence is high in that dependency classification; external priority and root claim admission are not asserted. No new primary-paper review is counted here.