Remaining query symbols can pay for learned reindexing

13 October 2026. Written native construction 78. A sufficient subclass theorem using the Lab’s established serial dictionary, FIFO and bounded-batch primitives. No root admission or external priority claim.

The unchanged-suffix result below is preserved. Construction 79 subsequently permits fixed-delay transformations, and construction 80 adds growing delay and bounded speculative width. The current checkpoint records the remaining frontier.

Result and example

A source can keep one activation dictionary while arbitrarily many independently prepared namespaces read it through different stored maps. The query first identifies its namespace and an input-built replacement prefix. Its remaining suffix pays both the replacement-prefix lookup and the replay of suffix bits that arrived during that lookup. The answer is ready by the query delimiter. Activating a store never updates every namespace.

For example, split an ordinary suffix into equal nonempty halves a and z. Namespace i may use any table sigma_i on the first half, and interpret the target as the foreign store named by 1 sigma_i(a) z. Different namespaces may use unrelated tables, with their number growing with the input. The second half z is meaningful key data, not added padding. The construction exploits its actual remaining service time.

This closes a structured growing-namespace case of the independent-reindexing frontier. It does not handle arbitrary permutations of the entire suffix: if the final bit is needed before any useful owner spelling is available, the present schedule has no remaining service window.

1. Exact checked language

Use construction 77’s ordinary right-first records and fixed phase delimiters:

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

Here E replaces each binary bit d by 0d and appends 11. All names are ordinary nonempty binary words; v is the single alias bit 0 or 1. Require a nonempty right block. The first store establishes an odd width m=2r+1 with r>=1. Every right and left store has that width. Stores occupy once-only nonempty contiguous right groups, and left stores must exist in the frozen store directory, exactly as in construction 77. Source names remain unrestricted.

Each right target must have the form

$$q=E(c)az,\qquad c=0i,\quad |c|=m,\quad |a|=|z|=r.$$

Thus its literal length is 3m+1. No separators between a and z are supplied: the learned unary half-ruler determines the split.

A store b beginning with 0 must equal c. It contributes a primary incidence. A store beginning with 1 has the unique spelling b=1 alpha beta, with both halves of length r, and contributes a foreign incidence. Require beta=z. Across all foreign records with the same pair (c,a), require the same alpha. These records define a partial, arbitrary input-built function sigma_c(a)=alpha. Injectivity, totality and complete permutation tables are not required or assumed. Repeated records are allowed. The consistency test is global, including records in different store groups.

The final target t can be any nonempty binary word. A wrong shape, wrong length or absent target means false product membership, not rejection of an otherwise valid pinned formula. Structurally invalid right/left input rejects. The accepted language consists exactly of the structurally valid formulas whose pinned Horn formula is satisfiable.

Alias 0 activates the selected store; alias 1 contributes no right edges and never retracts activation. At most two distinct stores own any target: its primary c and its uniquely determined foreign 1 sigma_c(a) z. Both owners need not actually occur.

2. Static preparation and the representation identity

Prepare the global store dictionary, two static target-support bits P(q), F(q), and a nested static map D(c)(a) containing the literal alpha stream. P records actual primary incidences and F actual foreign incidences. A source u has just one persistent activation dictionary B_u on decoded store names.

For a well-shaped target q=E(c)az, the invariant gives exact product membership

$$M_u(q)=(P(q)\land B_u(c))\lor (F(q)\land B_u(1\sigma_c(a)z)).$$

The second term is false if D(c)(a) is missing. On admitted right input, F(q) already guarantees that this map entry exists. For an off-shape target both terms are false. The support bits are essential: a partial map does not create edges for unobserved suffixes or primary stores.

To prove the identity, divide actual right witnesses by their store’s first bit. A primary witness must be c. A foreign witness must equal 1 alpha z, with alpha fixed by the checked (c,a) entry. Conversely each marked support term comes from its actual recorded owner. This proof also covers noninjective sigma, duplicates, sparse tables, missing sources and repeated selections.

3. Construct and validate the map during ordinary input

Inherit the pointer-valued serial capsule dictionary, strict persistent FIFO and bounded simultaneous-record compiler used by construction 77. Opening a path costs one fixed local step per actual key bit; closing the retained path capsule with a fixed-arity payload costs bounded work. No mutable backpatch is introduced.

During the first decoded b, retain a full unary width ruler. After its first bit, a two-state parity controller adds one cell to a second ruler for each pair of remaining bits. The delimiter checks a positive even tail and hence m=2r+1, r>=1. This constructs the half-ruler from actual input. Subsequent name and target checks use fresh read-only cursors on the retained rulers, with no integer arithmetic or supplied r.

Each right b field opens the store path, checks width and group discipline, and prepares a FIFO of its decoded bits. For a foreign b, omit its leading 1 and retain the remaining 2r-bit stream. While the following actual E(c) arrives, dequeue its first r bits into a separate alpha FIFO using the half-ruler, leaving beta ready in the original queue. A fixed rate finishes this work during E(c), whose actual length is 2m+2. The first record already has both rulers before q starts. In parallel validate c’s role and width, compare a primary b with c, open the outer D(c) path, and traverse the global target-support builder.

For a foreign record, during the first r suffix bits a, open the inner map path D(c)(a). At the last a bit its old payload is available. Save the old alpha stream, if any, and provisionally close the inner and outer map paths with the newly prepared alpha pointer. These are a fixed number of closures at a boundary detected by ruler exhaustion.

During the next r actual bits z, compare beta with z one bit at a time. In parallel compare saved old alpha with new alpha, also one bit at a time. If no previous map entry existed, only the beta comparison is needed. Equality includes exact exhaustion. At the target delimiter reject any length, shape or consistency failure. Otherwise commit the provisional map root and the appropriate P/F support bit. Primary records leave the map unchanged. Previously committed roots remain available until the transaction succeeds; rejecting or discarding a provisional path needs no rollback traversal.

Consequently the entire right block prepares D, P and F from actual records. Group closure and the right/left phase boundary require no scan. Queues, speculative paths, discarded records and comparisons are all charged to their containing literal records.

4. Activate once, without namespace fanout

During a left source field u, open its current source-header path. During E(b), validate the known store and traverse the current B_u path on the decoded b bits. Alias 0 sets its terminal activation flag. Alias 1 preserves the old root. Close the inner and outer capsules in bounded endpoint work.

Thus B_u contains exactly the stores selected for u with alias 0. An activation requires no access to D, no namespace enumeration and no materialized target union. Interleaved sources keep independent current roots. Every retained source version remains immutable; a later query captures its selected version rather than following an old store pointer into stale source state.

The raw intermediate variable is E(b)v, but the internal activation key is b. This decoding is performed during the actual encoded input, with the alias checked separately. It is not an assumed equivalence between raw and decoded languages.

5. The remaining suffix pays the complete lookup

The positive pin selects B_s by its actual source bits. Throughout target t, traverse the frozen support trie. While E(c) arrives, parse c, look up D(c), and traverse B_s(c) for the primary activation bit. These tasks use a fixed number of cursors. In a foreign lane, start at B_s’s child 1; that one fixed step can occur before the suffix worker begins.

The next r bits a traverse D(c)(a). At their end, the learned alpha handle is ready. A missing map disables this lane. Otherwise launch a worker with the current foreign activation cursor and the alpha stream. The remaining actual bits z enter a strict FIFO in a separate fixed ingestion lane.

The worker first traverses the activation dictionary along alpha, then traverses it along queued z. Each normalized service step is one stream pop plus one dictionary advance, or a bounded stage transition. Normalize setup and the change between streams as two additional steps. Across a valid r-bit suffix, the worker requires at most

$$r+r+2\le4r$$

such steps. Run up to four normalized steps after each arriving suffix bit; each is implemented by a fixed number of old-top primitive operations, absorbed into the fixed batch constant.

This total bound also meets release times. Alpha is wholly available before the first z bit. Each z bit is enqueued before that symbol’s worker service. If the worker never idles, its 4r slots cover every task. If it idles, it has completed alpha and consumed every z bit so far; every subsequent arriving bit requires only one data step and the bounded stage overhead, so its own batch suffices. Thus even r=1 finishes by the last valid suffix bit. A terminal flag observation and final Boolean negation are charged to ordinary punctuation, with no EOF work.

An underlength or off-shape final query need not finish this worker. Its exact static support flag is false, so the foreign term is false and unfinished work is abandoned. An overlength query similarly disables the fixed-shape lane. Well-formed unsupported queries remain valid SAT inputs. No flush or structural rejection is substituted for that support-guarded answer.

At the final semicolon output the complement of the ready primary/foreign OR. All source access uses the one captured current B_s. The query may allocate replay queues, but does not mutate that source version or the static maps.

6. Native resource theorem

Theorem 78. One deterministic native scaffolding automaton recognizes exactly the checked satisfiable language in section 1. Namespace count, map sizes, store count, source dependencies and widths may grow. The half-width is learned from input, not built into a nonuniform family.

For the established record spelling, the actual encoded length is

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

where e(b)=2|b|+2; fixed phase delimiters contribute their actual additional symbols. Right q has length 3m+1. No padding or extra work symbols are added.

Each right symbol performs bounded parsing, ruler, FIFO, comparison and dictionary work. Each left symbol performs bounded store and activation work. Each pin symbol performs bounded static lookup, map routing, queue ingestion and worker service. There is no group-size, namespace-count or source-history dependent endpoint task. All preparation, initialization, old-storage observations, allocations, pointer/name routing, rejected speculative work, replay, output and retained versions total O(N) logical records and work. Explicit binary pointer serialization costs O(N log(N+2)) bits.

All cursors, stage flags and root tuples have fixed arity. Rulers and names are ordinary immutable bounded-degree records; no unbounded value is hidden in a label or controller. The established simultaneous-record compiler fixes degree, radius and finite control, with old-top observations and bounded chronological batches, and gives N+1 physical nodes after fixed initialization. No address, identity, metadata, timing or control-flow side channel is used. The PEG consequence concerns the reversal of this entire checked language only.

7. Why this addresses growing reindexed views

For m=2r+1, choose arbitrarily many distinct primary names c=0i and foreign stores 1 alpha z. In each namespace choose an arbitrary permutation sigma_c of the r-bit words and record every primary and foreign incidence for q=E(c)az with alpha=sigma_c(a). The complete suffix map is

$$\pi_c(az)=\sigma_c(a)z.$$

The number of namespaces may grow up to $2^{2r}$. Every foreign store owns one target in each namespace, so no fixed foreign-packet bound in construction 77 covers the family. The source’s activation remains stored once. There is no free relabeling of target names: these are the actual admitted names.

Input-built prefix-tree automorphisms were already covered by section 16, including the required producer. Applying that theorem to construction 77’s coding requires paid decoding of b, not treating E(b)0 as one output bit per suffix symbol. That specialization is a retained control, not a new result.

The present construction tolerates unbounded ambiguity before its mapped prefix is released. For sigma_c(a)=rev(a), fix a target prefix E(c) followed by k initial bits of a. Any section-16 one-tick-per-symbol clock exhausting decoded b of length 2r+1 by the target end must already have ticked at least k+1 times: only 2r-k target bits remain. Apart from the fixed leading 1, at least k bits of reversed a have been exposed. The unknown last r-k bits of a give at least $2^{\min(k,r-k)}$ distinct exposed foreign prefixes. At $k=\lfloor r/2\rfloor$, no fixed ambiguity bound works. This comparison even grants decoding first, and does not assume a particular clock.

This is a failure of that earlier criterion, not a native lower bound. The new reader waits for a single map result and catches up using meaningful remaining suffix input. No separation from every previous sufficient theorem is claimed. The written contribution combines established primitives into this charged growing-view subclass; external originality has not been assessed.

8. Next boundary and evidence

The independent audit checks sparse and complete tables, noninjective maps, direct Horn semantics, retained versions, rejected producer conflicts and the explicit service schedule. Its Python containers are semantic oracles, not native instructions. The assessment review records adversarial review and finite counts.

The next test at this assessment was to remove the unchanged suffix condition. Determine whether independently learned maps can transform the suffix too while releasing each new lookup early enough to pay routing and replay from actual remaining symbols. Arbitrary whole-suffix permutations remain open. A fixed number of phases alone is insufficient if the last phase releases an unbounded key at the endpoint; every release needs its own service argument.

Replay slices charge all consumed bits again when replayed. Affine joins do not supply arbitrary learned coordinate maps. Causal persistence supplies retained histories, not the missing schedule. Unary coherent algebra does not imply general branching composition. Imported entry 129 retains its growing-alphabet state/port bounds; this construction uses exact local membership, sharing and negative readout, without a matching or positive-path extraction.