Current shared answers across unbounded name lengths

Assessment 243, 13 October 2026. Written construction 85. A sufficient native subclass theorem; no new root admission or unrestricted lower bound.

Result and motivation

Construction 84 keeps a recent activation directly readable while a later record pays to install it in a shared index. Its common owner width prevents a short record from inheriting an arbitrarily long installation. Here each source instead keeps one pending receipt in each occupied length class. A short record services nearby lengths and leaves distant receipts intact. The query selects its own class before it starts reading the shared index.

For example, a source may activate a 33-bit owner, then a 513-bit owner, then a 35-bit owner. The 513-bit record installs the earlier 33-bit receipt while servicing shorter classes. The later 35-bit record leaves the 513-bit receipt pending. A later query for that long owner selects the other class and compares its still-pending receipt directly. The source has one directory root, not a growing tuple in finite control.

Construction 85. Allow the checked owner widths in construction 84 to vary across records, subject to the local incidence conditions below. One fixed deterministic native recognizer handles arbitrary interleavings of widths, sources and learned namespaces, with bounded work per actual symbol and timely final answers. Occupied owner fibres remain unbounded. The representation is a full activation dictionary plus a length-class directory whose entries contain an installed shared index and at most one pending owner.

The proof adapts section 15’s class-window installer. The added argument is that its buckets can be selected early enough for the learned-filler query, including parsing and testing a pending owner of a possibly different width. It is a written extension of established Lab methods.

1. Local widths and checked ordinary preparation

Keep the ordinary right-first Horn syntax, source alias semantics, contiguous once-only store groups, exact known-store checks and late pins from construction 84. E encodes each bit d as 0d and appends 11. Every store has some odd width

$$m=2n+1,\qquad n\ge8,$$

but there is no common n. In each actual right incidence the namespace c starts in 0, has the same width as b, and the target is q=E(c)az with both a and z of length n. A primary owner satisfies b=c. A foreign owner has

$$b=1\alpha E(v)w,\qquad |\alpha|=n,\quad |E(v)w|=n,\quad v\ne\epsilon.$$

Retain the aligned E parser and all namespace-local seed, filler and synchronous short-map conditions. In particular each namespace with foreign support learns ell and w_c from its first actual foreign seed, with

$$n\ge4\ell+4,\qquad |w_c|=n-2\ell-2.$$

The same namespace spelling determines the same n. The foreign owner is $1\sigma_c(a)g_{c,a}(z)$, where $g$ is the exceptional $E(f(t))w_c$ on $z=0^{n-\ell}t$ and is $z$ elsewhere. Support P(q), F(q) remains exact. The global first-foreign-store bootstrap is no longer required; primary records may come first. The lower bound n>=8 is checked locally and excludes unused small-width cases rather than hiding them in a global bootstrap.

While actual b arrives, save its full spelling in a strict FIFO and collect its m ruler. After its first bit, every pair of further decoded bits adds one cell to an n ruler. A finite parity flag and saturated small counter check oddness and n>=8. This does not split alpha before n is known. During actual E(c), replay the saved b using the now-ready n ruler, obtaining alpha, v and w exactly as in construction 84. Compare the arriving c length with the saved m ruler, including exact exhaustion. There are 2m+2 actual E(c) symbols in a valid row, enough for the m-bit replay and bounded setup at fixed rate. All later seed, a, z and consistency checks use this row’s rulers. A shorter or malformed c rejects without needing to finish speculative work.

Thus every row bootstraps its own paid shape. No width header or decomposition is added to the input. The namespace directory, learned descriptors and support builders retain fixed arity; the growing collection of namespaces remains in paid tries.

2. Width-tagged keys and the exact current invariant

Put $j(m)=\lfloor\log_2 m\rfloor$. This is an explanatory integer, implemented by the section-15 unary doubling clock. Define

$$K(b)=0^n1\,E(w)\,\alpha\,E(v).$$

The unary width tag is generated from the paid ruler; it is internal index data, not input padding. Decode the tag, then E(w), then n alpha bits and E(v). This proves injectivity across all admitted widths, including different widths within one class. The length is

$$|K(b)|=4n-2|v|+1\le4n-1<2m.$$

Each source u retains a full activation trie I_u and a capsule-list directory D_u. Bucket j has installed key trie J_(u,j) and optional pending receipt p_(u,j). A receipt contains the full owner FIFO and its paid width rulers. It need not contain pre-split components. For each known foreign b the invariant is

$$I_u(b)=J_{u,j(|b|)}(K(b))\lor[p_{u,j(|b|)}\text{ spells }b].$$

Unrepresented buckets are empty. Growing bucket counts do not enlarge a control tuple: the directory has bounded-degree records and an implicit blank suffix. Completed descriptors and receipts are immutable. Primary bits reside in I only.

3. Installing pending owners with a length-class window

The literal source name selects I and D and suspends its paid outer capsule. During decoded bits of the subsequent actual owner b, run the doubling clock and section 15’s s=0 window. At every boundary 2^j, bucket j is current and its old pending receipt has been completely installed. During the following 2^j bits, prepare bucket j+1. If the owner ends before the next boundary, discard that unpromoted speculative job and retain that bucket’s original state.

To install a receipt of length m’, first parse its saved full spelling, using its stored n’ ruler, into alpha, v and w FIFOs. Then insert K along its width tag and three component streams, mark the terminal and close its capsule. Parsing uses m’ bit jobs and insertion uses fewer than 2m’ key jobs. Each job includes a bounded amount of parser, FIFO, old-storage and allocation work. Fixed setup and endpoint operations have their own fixed sub-batch.

A receipt in bucket j+1 has m’<2^(j+2). Consequently its parsing and insertion use fewer than

$$3\cdot2^{j+2}=12\cdot2^j$$

bit/key jobs. A fixed rate such as 32 normalized jobs per decoded incoming bit covers this work and fixed transitions within the interval. This is a macro-job rate, not a claim that every job is one raw pointer operation. The fixed local compiler expands each bounded macro. The initial bounded set of tiny buckets is empty under m>=17 and can also be serviced by a fixed initial batch.

The capsule-list window uses a FIFO of paid frames for the prefix and a separate untouched suffix. Moving or closing the fixed window does not walk back over the directory. Preparing the next bucket never overwrites an unfinished receipt. This is precisely the section-15 directory contract, now applied to owner-key installation with a larger fixed job constant.

In parallel, the incoming b traverses the known-store and full-I paths, is saved as a FIFO, and builds its own width rulers. At its endpoint the selected class j(m) is already drained. Alias 0 commits the marked I, completed directory service and this new pending foreign receipt in that bucket, or no receipt for a primary owner. Alias 1 restores the complete old I,D descriptor. It also restores every original pending receipt. All speculative and discarded work is charged. Unknown names and malformed syntax reject.

Draining replaces a pending equality by its installed flag without changing the logical set. The new activation adds exactly its own mark and receipt; primary records add no foreign bit; rollback adds nothing. Induction proves the invariant independently for every source and class. Distant buckets need not be serviced by short records. No operation visits namespace consumers or scans all pending receipts.

4. Early bucket selection and timely pending readout

The positive pin captures the source’s current I,D. During E(c), the decoded c bits traverse the namespace directory and read primary I(c). A separate doubling clock moves a read-only cursor through D, one bucket at each power-of-two boundary. At the end of c it has selected j(|c|). No J-key traversal has yet been needed. Unlike section 15’s general target reader, this reader does not need to replay the consumed c prefix: the shared key begins only after c.

The actual c bits also build the query’s n and m rulers, with parity and minimum checks. A failed query-shape check disables the unsupported candidate and yields false guarded membership; it does not reject an otherwise well-formed formula. Ordinary syntax errors still reject. A supported namespace supplies its frozen filler, ell and map metadata. For foreign readout, during the n bits of a:

• Traverse 0^n1 E(w_c) in the selected installed trie, at four key jobs per bit. Its length is 3n-4ell-1, strictly below 4n. Separate fixed setup/endpoint work remains charged.
• Parse the selected pending full-owner FIFO into alpha’,v’,w’ using its own saved n’ ruler, at eight parsed-bit jobs per bit. If absent, this lane is disabled.
• Compare the pending width ruler with the query width, including exact exhaustion. A mismatch makes the pending answer false. The comparison can stop once either ruler ends, so it costs at most m+1=2n+2 paired steps and fits four steps per a bit.

The selected pending owner lies in the same class as m, so

$$m'<2m=4n+2.$$

Eight parse jobs per a bit therefore complete parsing with strict slack for n>=8, even with a fixed startup allowance. A pending owner of another width is never mistaken for this one; parsing it speculatively is nevertheless affordable. No path to a distant pending bucket is followed.

At the start of z, sigma_c(a), the short program and all pending components are ready. During its first n-ell symbols, the installed worker traverses alpha at four jobs per symbol. Two separate pending-comparison lanes compare alpha’ with sigma and w’ with w_c, also at bounded rates. If widths match, alpha has length n and w_c<n; if they do not, the pending candidate is already false. Exact filler exhaustion detects both shorter and longer fillers. The common bound

$$n+2\le4(n-\ell)$$

pays these lanes before the final ell symbols. During those symbols, each synchronous f output releases its two encoded key bits, with two final delimiter bits on the last symbol. Four key jobs per symbol suffice. Compare the same outputs directly with pending v’, requiring exact exhaustion after the last output even if |v’| differs from ell. A separate fixed terminal sub-batch observes the ready answer.

The exceptional foreign bit is installed membership OR the width-checked conjunction of the three pending comparisons. The ordinary alternative uses the inherited full-I worker at 1 sigma z. The shape check selects between ready alternatives. Exact support yields

$$M_u(q)=(P(q)\land I_u(c))\lor(F(q)\land H_u(q)).$$

The invariant proves this is precisely relation-product membership. The final ordinary punctuation pays its Boolean complement, the pinned Horn SAT answer. Missing sources, unsupported targets and missing map paths cannot borrow another bucket’s answer; syntax errors reject. There is no final flush or EOF traversal.

5. Resources, payoff and boundary

The actual encoded length remains construction 84’s literal N, with each record’s own e(b)=2|b|+2 and all actual delimiters counted. No padding or advice is supplied. Every clock, width tag, directory step, pending parse, key insertion, query comparison, discarded job, old-storage observation and allocation is paid by ordinary symbols. O(N) logical work and retained records suffice; binary pointer serialization is O(N log(N+2)) bits.

The fixed simultaneous-record compiler gives finite labels/control, fixed degree/radius, fixed initialization and old-top observation semantics, with N+1 physical nodes after initialization. At any instant only a fixed directory window and fixed number of workers are active. The unbounded collection of pending receipts is distributed in paid directory records, not placed in one unbounded label or scanned in one transition. Pointer equality, addresses, timing and metadata are not communication channels. One fixed machine handles all admitted widths. Native recognition gives a PEG for reversal of this complete checked language only.

This removes the global-width service condition of construction 84 for the explicitly stated local-width language. A source can mix arbitrarily many length classes and retain one readable pending activation in each. The earlier finite-fibre limit also remains absent. The mechanism supplies a charged composition criterion: localize deferred work by the scale of the actual operation, make each selected scale serviceable before replacement, and route queries to that scale before producing the shared key.

A single pending slot for all widths fails when a short record overwrites an uninstalled long owner. Keeping every such word in one list would lose the fixed parallel-read bound. Class partitioning repairs both failures here. Omitting a width distinction from a shared reordered key lacks the cross-width injectivity proof; the explicit tag repairs it and its cost is included. These are representation-specific diagnoses, not native lower bounds.

Replay still charges each query fork; affine joins grant no free coordinate change; causal persistence grants no free current-answer route; unary coherent consumers do not imply arbitrary branching joins. Entry 129’s imported state/port bounds keep their original matching and positive-path hypotheses and growing-alphabet distinction. No root claims are changed.

The remaining local condition is that each supported owner and namespace have matching width. The next decisive test is cross-scale reuse: a much shorter ordinary target selecting a much longer activated owner, with unbounded image and no supplied route. Determine whether paid preparation can supply a shared current predicate without traversing the long owner at query time. Preserve arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service as open. The old explicit-installer cross-scale obstruction in section 15 is a control, not a universal conclusion.

Independent finite checker and review separate bounded evidence from the written general argument.