Shared activation indexes bypass long private tails

13 October 2026. Written construction 81, independently reviewed. No root admission or external priority claim.

Result and motivation

The preceding cross-index attempt exposed a distinction between completing work and making its answer accessible. Its sparse exchanged-leaf family has linear total routing, yet a query cannot freshly prepare all the long paths it might select. This note moves a specific, fully charged operation earlier: ordinary activation records maintain two short-key indexes shared by all namespaces. The late query reads a current answer through a short key instead of traversing the long constant tail.

For example, at $n=8$ and $\ell=3$ the suffixes 00000101 and 10110000 are exchanged. Both use the short varying key 101, in different typed indexes. Activating either full owner validates all eight suffix bits but records its answer under that three-bit key. A later query need not reconstruct the other eight-bit suffix.

The representation retains three activation roots per source, independent of namespace count. It does not prepare a separate current table for each namespace. Arbitrary learned prefix maps remain in static storage. The additional restriction is one common, input-learned shape for the exceptional suffixes. This gives a sufficient subclass, not an arbitrary permutation reader or a general lower bound.

Construction 81. The checked language defined below has one deterministic native recognizer for all admitted widths and all numbers of namespaces. Preparation, activation, lookup, validation, discarded provisional work and final output have bounded cost per actual symbol. Earlier construction 80 remains available as a separate sufficient class. The new construction handles its sparse exchanged-leaf counterexample without its growing simultaneous frontier.

Construction 82 subsequently allows namespace-specific cut lengths through shared boundary-normalized indexes. It adds a first-foreign seed requirement at each namespace; the broader seed-order scope of this earlier construction is preserved.

1. Exact ordinary input and learned shape

Retain construction 78’s right-first syntax, store grouping, known-store checks, aliases and source pins:

right: (-01E(b)0,+1q);
left:  (-00u,+01E(b)v);
pins:  (+00s);(-1t);

E replaces each bit d by 0d and appends 11. Alias v=0 activates the store; v=1 does not. The first actual store has odd width m=2n+1. All stores have this width. Targets in right records have the form q=E(c)az, with c beginning in 0, |c|=m and |a|=|z|=n. The ordinary first store constructs n’s unary ruler as in construction 78. Source names have no fixed width.

Require the first right record to be foreign: b=1 alpha beta with |alpha|=|beta|=n. Let ell be the number of beta positions strictly before its last 1. Require a last 1, ell>=1, and n>=2ell+1. These values are inferred from this actual incidence, not supplied as a decomposition. Freeze the resulting rulers for the entire input. Define

$$A(t)=0^{n-\ell}t,\qquad B(t)=t1\,0^{n-\ell-1},\qquad |t|=\ell.$$

The first target suffix must be A(t), paired with that first beta=B(t). This is a real recorded edge and participates in support; it is neither an extra work record nor padding. Primary-only tables and tables with a different first record are outside this checked language. No claim of unrestricted record-order invariance is made. After this seed, records may occur in any order consistent with the inherited contiguous once-only store groups.

The A and B sets are disjoint: every A word has zero in its first n-ell positions, whereas a B word has 1 at position ell+1<=n-ell. Let pi exchange A(t) and B(t) for equal t, fixing every other n-bit word. This is a bijection and an involution.

For every later primary incidence require b=c. For every foreign incidence b=1 alpha beta require beta=pi(z). At each (c,a), all foreign incidences must agree on alpha, defining an arbitrary partial learned map sigma_c(a). Sparse tables, noninjective sigma and duplicates are allowed. Preserve exact original-name primary and foreign support P(q),F(q). Off-shape or unsupported final target names have false product membership, as in construction 78; they are not rejected merely for being outside the right-table shape. Invalid preparation or malformed syntax does reject.

2. The shared representation and its invariant

For each source u retain one immutable tuple (I_u,J_u^A,J_uB). I_u is the ordinary activation dictionary on full decoded store names. The auxiliary indexes have the concatenated key alpha t, whose split is fixed by the learned rulers:

$$J_u^A(\alpha t)=I_u(1\alpha A(t)),\qquad J_u^B(\alpha t)=I_u(1\alpha B(t)).$$

Missing terminals mean false. Every tuple describes the same completed left prefix. A query captures this tuple by the ordinary source pin. It does not follow an old static owner pointer to obtain a current value.

Define the foreign answer H_u(alpha,z) by

$$H_u(\alpha,z)=\begin{cases} J_u^B(\alpha t),&z=A(t),\\ J_u^A(\alpha t),&z=B(t),\\ I_u(1\alpha z),&z\notin A\cup B. \end{cases}$$

Then for supported well-shaped q=E(c)az,

$$M_u(q)=(P(q)\land I_u(c))\lor (F(q)\land H_u(\sigma_c(a),z)).$$

To prove this identity, a primary witness is exactly c. The checked foreign witness is exactly 1 sigma_c(a) pi(z). Substituting the three cases of pi gives H. Conversely each support bit denotes an actual incidence with that owner. The support guards prevent an index from inventing an edge merely because its shortened key is present. This remains true for missing sources, duplicate incidences and absent primary owners.

This is not a quotient that identifies arbitrary activation bits. On each exceptional shape, t determines its full beta uniquely, and the A and B indexes are separate. Their long literal tails still participate in validation and in the actual encoded length.

3. Bootstrap and right-table validation are paid

Use the established serial capsule dictionaries, strict persistent FIFO and bounded simultaneous-record compiler of construction 78. A capsule opens a path one ordinary bit at a time and closes its fixed-arity payload in bounded endpoint work. Its unbounded saved path is charged storage, not a free array or backpatch.

During the first decoded b, construct the full and half rulers and retain its bits in a FIFO. During the actual E(c) field, move the first n foreign bits into an alpha stream, leaving a persistent beta stream, exactly as in construction 78. Retain beta’s starting root. During the following n actual a bits, scan beta once. Maintain a unary position chain. Immediately before each scanned 1, save the current chain root, then extend the chain for that position. Also reset a separate unary trailing-zero chain at each 1 and extend it at each later 0. At beta’s end, the saved root has length ell and the trailing-zero chain has length n-ell-1. Prepending one cell gives the n-ell ruler. Saving a chain root and resetting a root are bounded pointer operations; no subtraction, integer arithmetic or pointer-identity test is used.

During z, traverse fresh copies of the ell and trailing-zero rulers in parallel until the ell ruler is empty. If the trailing-zero ruler expires first, reject. Also reject empty ell or a missing last 1. This verifies n>=2ell+1 during actual input. In another lane, require the first n-ell z bits to be zero, then compare its last ell bits with the first ell bits from the saved beta stream. Require exact exhaustion at the target delimiter. These checks certify the seed A(t),B(t). A failed seed abandons all provisional roots and rejects; there is no accepted computation using its unvalidated rulers.

For every later foreign row, E(c) again prepares alpha and beta streams. During a, scan beta with the now-frozen rulers. Prepare the two candidate t streams, recording whether beta has exact A or B shape. Preserve beta’s original stream for the identity comparison. During z run three comparisons in parallel:

1. classify z as A and compare its terminal t with the saved B-candidate t;
2. classify z as B and compare its initial t with the saved A-candidate t;
3. compare z with the full saved beta stream.

At the delimiter select the first comparison if z is A, the second if z is B, and the identity comparison otherwise. The selected comparison must have the matching beta shape and exact stream exhaustion. A provisional error in an unselected comparison is ignored. Since A and B are disjoint, selection is unambiguous. This accepts exactly beta=pi(z), including identity words with prefixes resembling an exceptional shape but with an incorrect tail.

As in construction 78, actual c and a bits open D(c)(a), with its old alpha stream retained. The n z bits compare old and new alpha; a disagreement rejects. Store support and the new map together only after all checks succeed. For primary records, compare b with c and maintain support without changing D. The fixed number of scans, streams, flags and suspended capsules costs a fixed local batch at every symbol, including the seed. No scan is deferred to the right/left phase boundary.

4. Activation updates a constant number of current indexes

During the actual source field u, open the source header containing the three roots. During E(b), validate b in the frozen known-store directory and provisionally open its full I_u path. If b starts in 1, its n alpha bits simultaneously open paths in both auxiliary dictionaries. The following n beta bits run both shape parsers:

• the A lane skips and validates its initial n-ell zeros, then extends its auxiliary path on t;
• the B lane extends its auxiliary path on the initial ell bits, then validates the 1 and the remaining zeros.

Each lane may close a provisional marked root once its key has arrived. Retain the old root as well until shape and alias are known. At the actual record endpoint, alias 0 commits the marked I_u root and just the auxiliary root whose complete shape test succeeded. For an ordinary beta, both auxiliary old roots survive. A primary b starting in 0 changes only I_u. Alias 1 retains all three old roots. Close the source-header capsule with the selected tuple in bounded work.

Induction on left records proves both auxiliary invariants: exactly one original store can map to each typed short key, and the only committed short update is its validated activation. Long-tail mismatches cannot contaminate shortened keys. Repeated activations are idempotent. All roots remain immutable, and each source version has a coherent three-root snapshot.

This update never reads D or enumerates namespaces. Its old-storage observations and allocations are independent of how many target views refer to the activated store. It uses a fixed number of dictionaries, not one dictionary per namespace or exceptional leaf.

5. Three readout lanes meet the final-symbol deadline

The positive pin captures the three current roots. During E(c), obtain D(c) and the primary bit I_s(c). During a, obtain the learned alpha stream at D(c)(a). The static support lane reads the entire ordinary target in parallel. A missing map or support path disables its foreign answer without a final search.

At the start of z, initialize three workers. Each alpha stream is an immutable cursor copied by its root, not copied bitwise. Normalize initialization and the switch to the short/full key as at most two extra jobs per worker. A job consists of bounded local stream, FIFO and dictionary operations. Every worker receives four jobs per actual z symbol, in parallel fixed batches:

Each suffix-key bit is enqueued before that symbol’s service. Classification is independent of service. Until the final shape check, even a worker for a shape that will fail receives its complete promised budget.

The ordinary worker is construction 78’s n+n+2 schedule. Any tail beginning in its initial jobs fits 4n slots; a tail beginning at z position j has n-j+1 jobs and that many remaining symbols. Thus it finishes by the last valid z bit.

For an A-shaped query, the initial alpha/setup work finishes within the first n-ell symbols because

$$n+2\le4(n-\ell),\qquad n\ge2\ell+1,\quad\ell\ge1.$$

The remaining ell bits each pay their own dictionary step as they arrive. This worker is already at the short-key root before its late t is selected.

For a B-shaped query, all key bits arrive among the first ell symbols and wait in a paid FIFO if alpha is unfinished. Its total work is n+ell+2<=4n. More precisely, a tail beginning in the initial jobs has all n symbols, and the suffix tail beginning at position j<=ell has ell-j+1 jobs with n-j+1 remaining symbols. Every ordered release tail fits. It therefore finishes by the last valid z symbol; no post-query replay is needed.

After z, exact shape flags choose the appropriate ready Boolean answer. The support bits and primary term give M_s(t); the final ordinary punctuation outputs its complement, the pinned Horn SAT answer. Short, overlong or off-shape query names are handled by exact original support. Their unfinished speculative workers may be abandoned when support is false. No EOF work is added.

6. Native resources and the separation actually obtained

The literal length is unchanged from construction 78:

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

where e(b)=2|b|+2; include actual phase delimiters as well. Initialization is constant. Ruler creation, preparation, all old observations, discarded allocations, validation, original-name routing, short-key routing, queues, source updates, retained versions and output cost O(N) logical work and records. Explicit binary pointer serialization costs O(N log(N+2)) bits.

There are always three activation roots and three foreign workers. Their number does not depend on n, ell, support size, source count or namespace count. Fixed-arity tuples, finite stage flags and ordinary bounded-degree ruler/queue nodes fit the inherited fixed-batch compiler. It fixes degree, radius, labels/control and old-top observation semantics and gives N+1 physical nodes after fixed initialization. Neither n nor ell is a machine parameter: one machine recognizes the whole checked class. There are no supplied handles, decompositions, padding, advice, free preprocessing, EOF work, or address/identity/metadata/timing/control-flow channels. The language is read in the stated right-first orientation. The standard native-to-PEG transfer gives a PEG for its reversal only.

Take n=2^ell, ell>=3, and complete foreign tables for pi, together with any learned maps sigma_c. Arrange a valid B-owner/A-target seed first. At z prefix 0^(n-ell), the possible owners have all 2^ell distinct first-ell beta prefixes. For every fixed C,W, eventually n-C ell>=ell and 2^ell>W. Thus these suffix tables fail construction 80’s fixed envelope-width contract. They are nonetheless recognized here through earlier paid short indexes. This separates sufficient contracts, not all earlier native classes or language families. The earlier mandatory-path lower bound remains correct for its explicit-path representation; these workers do not perform those paths.

Growing independently learned namespace views are still present: each sigma_c can be an unrelated permutation of the n-bit words, with a growing number of c values. All views read the same three current source indexes. The common suffix shape is a real restriction; arbitrary independently chosen suffix permutations are not admitted.

7. Controls, failed generalization and next test

Constant provisional lanes, exact support guards, delimiter commitment, shortening and coherent source versions are established controls from sections 17–18. This construction reuses them. Its added argument is the ordinary-record producer for an input-learned global contraction, composed with arbitrary learned alpha routing and source-shared auxiliary updates. Section 18’s fixed subsequential normalizer and bounded normalized right degree do not directly supply this result. That hypothesis comparison is not a universal noninclusion claim. Replay, affine joins and causal/cubical algebra retain their separate compiler and observation contracts.

The tempting generalization is a different shortening pattern per namespace. The present update proof then breaks: an activated store may have to change a growing number of different auxiliary keys, and the actual activation record offers no time proportional to namespace count. This disproves the proposed independent-copy implementation’s constant update bill, not every shared representation. Reopen it with a common input-built index that represents these patterns together and supports current answers through paid routing.

The next decisive test at assessment 237 was to allow an input-built family of different exceptional suffix patterns while retaining a bounded number of source-shared indexes. Charge discovery and validation of their common representation, updates from literal owner names, and late query selection. Determine whether a structural closure condition on the normalizers gives a useful composition criterion. Preserve arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service as open.

Independent finite audit and review distinguish the semantic experiment from the written all-length schedule. No imported theorem is strengthened or transferred to a native lower bound by this construction.

8. Dependent extension: learned maps on the short keys

The shared indexes also support independently learned suffix changes, provided those changes act synchronously on the short keys. This does not require additional activation roots. Keep the same seed and globally learned n, ell. For each (c,a), replace the fixed exceptional rules by partial maps f_A and f_B on ell-bit keys:

$$A(t)\mapsto B(f_A(t)),\qquad B(t)\mapsto A(f_B(t)).$$

Outside the exceptional sets require beta=z, as before. Each recorded map is prefix-consistent: inputs sharing j bits have outputs sharing j bits, for every j from zero to ell. In particular a complete input key has one output. The two maps need not be inverses, injective or total. The seed remains its stipulated identity-key A-to-B incidence and must agree with any later records at that key. Different (c,a) entries may have unrelated maps. Complete prefix-tree automorphisms on short keys are examples, not supplied descriptions.

To build the maps, add two static short-key trie roots to each D(c)(a) payload. Each occupied node at depth j>=1 stores one output bit. As the jth t bit of a right target arrives, descend on that bit and compare or install the jth output bit from the already prepared beta short-key stream. An occupancy flag distinguishes missing output from output zero. The shared prefix condition is exactly equality of these bits at every occupied shared trie node. Store a terminal flag at depth ell.

The target’s final shape is not known when either potential t segment starts. Therefore open both short-key builders from the old D payload: Q_B during the first ell z bits and Q_A during the last ell. Keep a separate provisional error flag for each. Both have their corresponding candidate beta keys prepared during a. If that candidate beta has the wrong shape, mark that builder invalid but do not let it reject the other choice. Preserve the old roots. At the final delimiter, z’s exact shape selects the valid provisional root and retains the other old root; an ordinary z retains both old roots and requires the full identity comparison. Alpha consistency and exact original support are committed in the same transaction.

The inner a capsule and outer c capsule now remain suspended through z so that the selected short-program roots can be included in their payload. This is the same fixed-depth nesting used in construction 80. The two short capsules and two outer capsules are a fixed number; closing them in a bounded batch does not traverse their depths. The first seed is processed the same way, with its identity-key bits compared and installed after the bootstrap supplies its rulers. The first ell positions of its z are zero and may feed an unselected provisional B builder; no invalid provisional branch is committed.

At query time, obtain Q_A,Q_B together with alpha at the end of a. The A and B query lanes traverse the relevant short trie as their respective t segments arrive. Its stored output bit, instead of the literal t bit, enters that worker’s FIFO. A missing node or terminal makes that lane unsupported. Actual F(q) implies the selected short path and its output were validated. The output has one bit at each of the same release positions used in section 5. Thus all four-job deadlines, the three-root activation invariant and the O(N) resource bill are unchanged. Current foreign membership is now J_s^B(alpha f_A(t)) or J_s^A(alpha f_B(t)). The proof is the same actual-owner substitution, without assuming invertibility.

This closes the directly dependent short-key-map extension in the same construction. The new content is their composition with earlier paid shared contraction; synchronous prefix maps and their one-bit producer are established controls. Taking both maps to be the identity retains the section 6 envelope-width separation. Arbitrary learned permutations of short keys are not admitted: if they release their whole output only at the final A-key bit, an ell-step short-index traversal is again too late. The historical next target in section 7 therefore concerns varying shortening patterns and their common current representation, rather than merely adding independent prefix maps to the already shared short keys.