Unbounded filler fibres with a deferred shared index

Assessment 242, 13 October 2026. Written construction 84. This is a sufficient native subclass theorem, extending construction 83; it makes no new root admission or general lower-bound claim.

Result and example

Independently learned filler words can share current activation answers even when unboundedly many owners have the same shortened key. The new representation retains the filler in a shared index and routes it early, before the query’s short suffix becomes known. An activation whose index insertion is not yet finished remains readable as one pending word. The next actual activation record for that source pays for its installation. Queries never need to flush this pending word.

For example, with n=8, two owners may have the same eight-bit alpha and the same short word v=0, but fillers 1010 and 1110. Their common short key in construction 83 was alpha E(0), requiring distinct finite slots. Here their index keys begin with E(1010) and E(1110), respectively. Activating only the first leaves the second answer false, whether the first activation has been installed or is still pending. At larger widths the number of different fillers at the same short key can grow without a fixed limit.

Construction 84. Remove the occupied-fibre bound K and its slot metadata from construction 83’s checked language, retaining its other conditions. One fixed deterministic native machine recognizes the resulting pinned Horn SAT language for all widths, source counts, namespace counts and fibre sizes. Every preparation step, activation and query has bounded local work per actual input symbol. Each completed source descriptor consists of two shared roots and at most one pending owner receipt.

The proof combines the Lab’s existing exact pending-overlay construction, section 15 with a new order for the learned-filler index. The consequential change is removal of construction 83’s finite collision restriction. This is a written extension of those methods, not a claim of external priority or a theorem about joining arbitrary independent heaps.

1. Exact language and a shared injective key

Use construction 83’s ordinary right-first Horn records, E encoding, contiguous once-only known-store groups, source aliases and late endpoint pins. E replaces each bit d by 0d and appends 11. The first actual right store must be foreign and bootstraps a common width m=2n+1. A primary store starts in 0. Every foreign store has the unique parsed form

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

The aligned parser rejects 10 before the first delimiter 11; all subsequent bits belong to w. Actual store spellings supply the data, including this decomposition. There is no bound on how many distinct stores share alpha E(v).

Targets remain q=E(c)az with |c|=m, c starting in 0, and |a|=|z|=n. Each namespace’s first foreign incidence is an actual seed. It learns a positive length ell and a filler w_c, with

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

The seed has z=0^(n-ell)t and owner suffix E(t)w_c. At each (c,a), ordinary records learn alpha=sigma_c(a) and a partial synchronous, prefix-consistent ell-bit map f_(c,a). For foreign support the suffix must be

$$g_{c,a}(z)= \begin{cases} E(f_{c,a}(t))w_c,&z=0^{n-\ell}t,\ |t|=\ell,\\ z,&\text{otherwise}. \end{cases}$$

Primary incidences have b=c. Exact original-target support keeps Boolean flags P(q) and F(q). The slot payload and the short-key count directory from construction 83 are deleted. Every other syntax, seed, consistency, group and support check is retained. The functional rules determine a unique foreign owner for each supported q, so removing slots does not remove an owner-consistency obligation. A primary-only namespace has no foreign descriptor and disables foreign workers.

Define the reordered shared key

$$\kappa(b)=E(w)\alpha E(v).$$

It is injective on the foreign owners at the checked common width: decode the initial self-delimiting E(w), consume exactly n alpha bits, then decode E(v). This recovers the whole owner. Different v lengths cause no ambiguity. Since |w|=n-2|v|-2,

$$|\kappa(b)|=2|w|+2+n+2|v|+2=3n-2|v|\le3n-2.$$

Self-delimiting the early filler is essential; a bare concatenation with a variable-length filler does not provide this argument.

2. Preparation remains paid by actual records

Retain construction 83’s width rulers, full known-store directory, saved owner streams, namespace seeds, filler comparisons, synchronous program builders and exact support tries. Its replay of b during actual E(c) works before and after width bootstrap. During a it parses the saved owner suffix, discovers or compares the filler, and builds the seed rulers. During z it checks the seed’s contraction inequality and zero prefix or validates the existing map and identity alternative. These are the same bounded batches on the same fields.

Delete the fibre-count traversal, slot allocation and slot-support payload. No replacement list of matching namespaces is built. The shared key is a fixed operation on each owner, not a namespace-specific index. The right block does not construct any source’s future activation set. Saved streams are strict persistent FIFO roots whose construction and scheduling were paid while their actual bits arrived.

3. A complete predicate with one physically pending insertion

A completed source u retains a fixed-arity descriptor (I_u,J_u,p_u). The full-name trie I records all activated owners. The installed trie J records reordered foreign keys. The optional pending receipt p is a tuple of FIFO roots for one foreign owner’s alpha, v and w. It is data, not a closure with hidden unbounded evaluation.

For every known foreign owner b the invariant is

$$I_u(b)=J_u(\kappa(b))\lor[p_u\text{ spells }b].$$

Initially the roots are empty and p is absent. All completed descriptors, paths and receipts are immutable. Terminal flags, explicit tuple fields and FIFO exhaustion are the only observations; no pointer identities or addresses are compared.

The literal source name u selects its current descriptor and suspends its paid outer capsule. During the subsequent actual E(b) field, execute these fixed parallel lanes:

1. If old p is present, install its key E(w_p) alpha_p E(v_p) into a provisional copy of J. The tuple already contains all three streams. Each key bit is produced and traversed at bounded cost, using the established capsule insertion and closure operations.
2. Traverse the full known-store directory and provisionally mark I at the arriving actual owner b.
3. For foreign b, collect alpha, decoded v and the post-delimiter w in three strict FIFOs. A primary owner needs no new pending receipt.

The installer has at most 3n-2 key jobs. A valid E(b) has 4n+4 actual symbols. Four key jobs per actual symbol, with a separate fixed setup/terminal sub-batch, complete the old pending insertion before this field ends. This remains true when the new owner is primary. All owners have the same checked width; another source’s records supply no credit. Invalid or short fields may abandon provisional work and reject.

At the following alias, alias 0 commits the marked I, the drained J and the new foreign receipt (or an absent receipt for a primary owner). Alias 1 restores the complete old triple. In particular, it restores the old pending word as well as both old roots. Discarded installation work is charged to the symbols that performed it. Unknown owners or invalid syntax reject. No traversal starts at the alias endpoint.

To prove the invariant, draining old p merely changes how the same logical set is represented. A successful foreign activation then adds exactly its new receipt and its full-name mark. A successful primary activation changes no foreign bit. Alias 1 changes nothing. Injectivity of kappa prevents interference between different owners; duplicate activations are idempotent. This proves the invariant by induction for every source separately. A source whose last activation is never followed by another record can keep its pending receipt forever without becoming logically stale.

4. Query scheduling routes the filler before the late short key

The positive pin selects and captures the complete current descriptor. During E(c), obtain the namespace descriptor and the primary answer I(c). All subsequent workers read this immutable version. Exact original-target support is traversed alongside the workers.

For a namespace with foreign metadata, the installed exceptional worker begins at J. During the n bits of a, traverse E(w_c), with four key jobs per bit. The filler stream was available when E(c) ended. Its length is

$$2|w_c|+2=2n-4\ell-2<4n.$$

A separate fixed sub-batch covers setup and observations; even one initial-bit delay leaves sufficient room under n>=4ell+4. At the end of a, sigma_c(a) and the short-program root are ready. During the first n-ell bits of z, traverse the n-bit alpha stream at four jobs per bit. The inherited setup allowance satisfies

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

Thus the worker is ready for E(f(t)) before t starts. Each of the final ell input bits produces one synchronous output bit and releases its two encoded bits. The last also releases 11. At most four key traversal jobs are released on any one late symbol; execute them on that symbol. The fixed terminal sub-batch observes the ready terminal after those jobs, or at the following ordinary punctuation. This accounting does not hide a fifth traversal inside the four-job allowance.

In parallel, a pending reader compares three components, without building or installing a key:

• During a, compare w_c with the saved pending filler, including exact FIFO exhaustion. One filler bit per a symbol suffices since |w_c|<n.
• During the early z window, compare sigma_c(a) with the pending alpha stream at four bits per symbol. The same n+2 bound applies.
• During the late t window, compare each output of f with the pending v stream. Test exact exhaustion at the end. Pending v need not have length ell; a shorter or longer word must fail this comparison.

Missing p makes this reader false. A mismatch can disable its lane without scanning the remainder of a stored word. An empty filler is represented by an empty FIFO, so its exhaustion observation is immediate. The queried namespace’s filler is nonempty under the contraction inequality, but ordinary stored owners may have empty fillers.

The pending answer is the conjunction of presence and all three exact comparisons. It is therefore precisely the pending equality in the invariant. For an exceptional z, the foreign answer is the installed J terminal OR this pending answer. The ordinary alternative retains construction 83’s separate four-job full-I worker on 1 sigma_c(a) z. The A-shape test selects between these ready answers; no branch selection initiates a path traversal.

At the deadline,

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

For an exceptional supported q, its prepared owner has key E(w_c) sigma_c(a) E(f(t)), exactly the installed worker’s key, and the pending reader tests that same owner’s spelling. The invariant makes their disjunction I_u(b). The ordinary branch reads the actual owner directly. Support flags correspond to actual right incidences, so M is exact relation-product membership. Its complement is the pinned Horn SAT answer, output at the final ordinary punctuation. There is no EOF work.

Absent sources use empty descriptors. Missing program paths disable that candidate. Absent or ill-sized targets cannot obtain membership because exact support is false; malformed overall syntax rejects separately. These cases require no deferred scan.

5. Resources and the structural sufficient condition

Keep the inherited literal length, with actual phase delimiters also counted:

$$N=\sum_R(10+e(b)+|q|)+\sum_L(11+|u|+e(b))+11+|s|+|t|, \qquad e(b)=2|b|+2.$$

Every filler bit is ordinary input data. Preparation, full-name routing, FIFO construction, old-storage observations, discarded work, provisional capsules, pending comparisons, allocation and output cost O(N) logical work and records. Each activation services only its selected source and one pending receipt, regardless of how many namespaces use that owner. Each query has a fixed number of workers. Binary pointer serialization costs O(N log(N+2)) bits.

The existing simultaneous-record compiler supplies fixed degree, fixed radius, finite labels/control, fixed initialization and old-top observations, with N+1 physical nodes after initialization. Each service job is a fixed local macro; its bounded batch is unrolled by that compiler. Root tuples have fixed arity, independent of n, ell or fibre size. All pointer routes and FIFO readiness used here were constructed on charged ordinary symbols. No advice, supplied decomposition, padding, ready handles, free preprocessing, identity or timing channels are introduced. One machine works across the entire stated language. The PEG consequence is recognition of its reversal only.

The mechanism gives a reusable sufficient condition for current composition and reuse: a fixed-size descriptor may combine an installed shared index with a bounded pending overlay, provided each next update of that descriptor pays to install its old overlay, and every query can decide the overlay alongside the installed index within its own deadline. A short induction gives logical currentness even though physical installation is deferred. Here common owner width pays installation, while the query’s early namespace descriptor exposes the filler before the short transformed key arrives. Both conditions are constructive and charged; semantic factorization alone supplies neither.

The completed replay controls still require each fork to pay its own readers. Affine-fragment joins grant no free coordinate change here. Persistent causal sharing preserves old versions, not uncharged access to new ones. Unary coherent cubical consumers do not imply a growing-branch merge. The native SAT control retains ordinary pins and the same checked input orientation. Entry 129’s imported state/port bounds remain about their matching or positive-path contracts, not this general branching representation.

6. Separation, failed routes and next test

For any fixed K choose n>=8 with 2^(n-4)>=K+1, ell=1, one alpha and v=0. Choose K+1 distinct fillers of length n-4 and distinct primary namespaces, each with its actual identity seed. Arrange once-only contiguous store groups. All those owners share alpha E(0), so construction 83 at K rejects; construction 84 admits these right factors. Choose satisfiable final pins to obtain accepted instances. There are enough ordinary c names to name these namespaces. Independent activations and supported queries distinguish each owner’s bit. Thus the fibre restriction is genuinely removed, not moved into a finite label or a namespace bound.

Immediate insertion into the reordered key is not justified by the earlier activation schedule: the leading filler becomes available late in the literal owner. Replaying a growing suffix after the owner ends would violate its deadline. The exact pending overlay repairs this route without assuming extra final symbols. Collapsing the fibre to one Boolean still gives construction 83’s false positive. Unbounded pending lists are unnecessary here and would not inherit the constant parallel-comparison proof.

The common owner width is load-bearing for this installer. A much shorter next same-source record need not pay for the previous long pending key. This is a scheduler limitation, not a lower bound for other native representations. The next decisive test is to remove the common-width hypothesis using charged local length classes, while preserving paid namespace routing, current pending selection and late transformed-key readout. Section 15’s class-window method is the direct control, but its bucket must be accessible at the correct time in this factored query. Arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service remain open.

Independent finite audit and review distinguish finite evidence from this general written argument.