Independent stores: separate service, bounded or routed readout

12 October 2026. Written native construction 76, with two interface contracts. This is a charged extension of construction 75 and the Lab’s persistent literal dictionaries. No root-ledger admission or external priority claim.

Construction 77 subsequently permits shared literal targets across unboundedly many selected full-row stores, under a routed-owner condition and bounded foreign scatter. It does not replace the omission-bearing row contracts here.

Result and purpose

Independently prepared stores need not agree on codes, birth order or support. Their selections can remain separate. Give each source a separate pending computation for each selected store, and service it only when an ordinary alias for that store arrives. At query time, either inspect a fixed number of store answers or use an ordinary prefix of the target name to route to one answer.

This separates two costs that a common code space would mix together: preparing a union within a store, and finding which stores can affect a future query. The number of stores in the input can be unbounded in both constructions below. The first bounds the number mentioned by each source and permits arbitrary overlapping target supports. The second removes that bound when target names expose their store through a self-delimiting binary prefix.

For example, one store may number target 001 by code 00, while another assigns 00 to 110. Comparing these codes across stores is invalid. We never do so. Each store computes its own answer to the literal query; the first construction ORs those Boolean answers. The second routes the query to its named store before running that store’s reader.

Structural criterion. Independent local preparation is reusable when deferred work has its own future service stream and final readout has either bounded independent fan-in or input-paid routing to boundedly many readers. A fixed global component count and a shared coordinate system are unnecessary here. This is a sufficient criterion for the explicit languages below, not a characterization of all native recognition.

1. Literal syntax and checked hypotheses

For a nonempty binary store name $b$, define a prefix-free encoding $E(b)$ by replacing each 0 with 00, each 1 with 01, and appending 11. Its actual length is

$$e(b)=2|b|+2.$$

The pair 10 is invalid. A finite parser detects the terminator; the following bits belong to the local alias or target. The words $b,u,v,w,a,q$ are nonempty binary words. Leading zeros in all names count. Sources, intermediate variables and targets have the disjoint binary prefixes 00, 01 and 1.

Fix $k\ge1$. Right records precede all left records and then the two terminal unit pins. Phase delimiters are the fixed delimiters inherited from construction 75. Store names, local names and delimiters are actual input, not supplied handles or decompositions.

Overlapping-support contract

Also fix $p\ge1$. Records and pins are

right: (-01E(b)v,+1w);
left:  (-00u,+01E(b)v);
pins:  (+00a);(-1q);

Here the displayed E(b) is its binary expansion, not an extra input token. Each source $u$ may mention at most $p$ distinct store names in its left records. Count distinct mentioned names even when their local aliases are absent. Different sources may use different stores, so there is no global bound on the number of stores or their union of dependencies.

Routed-target contract

There is no parameter $p$ and no bound on stores mentioned by a source. Records and pins are

right: (-01E(b)v,+1E(b)w);
left:  (-00u,+01E(b)v);
pins:  (+00a);(-1E(b)q);

The two store names in a right record must be literally equal. The target prefix is part of its ordinary variable name. Thus different stores have disjoint global target namespaces even when their local suffixes coincide. This is an explicit routing condition, not a promise of an externally supplied index.

Common checked conditions

Require at least one right record. Right records for each store occur in a single nonempty contiguous group. Store groups may occur in any order. A store that has been left cannot reappear in the right phase. A group’s actual first local alias and target determine its own positive widths $\ell_b,n_b$. All right aliases and targets within that group have these widths; a left alias naming that store must have width $\ell_b$. There is no width ratio condition, no common width across stores, and no bound on store-name length.

Let $X_{b,v}$ be a row of local target suffixes and $U_b=\bigcup_vX_{b,v}$ the store’s local support. When leaving a group, check

$$|U_b|-|X_{b,v}|\le k\quad\text{for every observed row in that group}.$$

Construction 75 maintains the ready minimum-degree flag implementing this check. Intermediate rows may violate it and later recover. Every left store name must exist in the completed right directory. An absent local alias denotes EMPTY. Final target suffixes have arbitrary positive lengths; wrong local widths and off-support words give false membership, not malformed syntax. An unknown final routed store likewise gives false membership. Syntactically malformed names, invalid grouping, unknown left stores and the stated width or dependency-gate failures reject the checked language.

The named groups are independently constructed within the charged input computation: their local updates use only their own records and state. The wrapper supplies literal directory routing and persistence. No arbitrary external heap or ready root handle is imported.

2. Recognition theorem and resource statement

Theorem 76. For each fixed $k,p$, the overlapping-support contract has one deterministic native scaffolding recognizer for exactly its checked satisfiable formulas. For each fixed $k$, the routed-target contract has one such recognizer with unbounded per-source store dependence.

Both machines have fixed degree, fixed observation radius, finite labels/control and input-independent initialization. Updates inspect the old top and allocate a bounded number of logical records per actual input symbol. All old-storage observations, name and pointer routing, preparation, speculative paths, allocation, deferred work and output are charged. No processing occurs after the final symbol.

For the overlapping contract the actual formula length, apart from the actual fixed phase delimiters, is

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

For the routed contract add another $e(b)$ for each right target prefix, and the final query’s $e(b)$ once. There is no padding term. The logical work and retained storage are $O_{k,p}(N)$ in the first case and $O_k(N)$ in the second. The inherited bounded simultaneous-record compiler gives $N+1$ physical scaffold nodes, with a fixed change of presentation. Explicit pointer serialization uses the corresponding $O(N\log(N+2))$ bits.

These are fixed automata for the indicated fixed parameters, not a machine family indexed by store count, widths or input length. The associated PEG recognizes the reversal of the entire checked language. No reversal closure of another language is assumed.

3. Prepare unbounded stores without reconciling coordinates

Keep a persistent literal dictionary $D$ keyed by store name. Its leaf payload is that store’s current construction-75 tuple, including its local widths, literal support, row directory, pool, window and ready gate flag. Retain the immediately preceding store name as a literal stream and its ready flag in the top-level header.

During each right record, the actual $E(b)$ bits pay two parallel tasks: traverse/open the store-dictionary writeback path, and compare the decoded name with the preceding store name. At the terminator:

• If the name is the preceding name, continue its existing store.
• If it differs and is absent from $D$, check the preceding group’s ready final flag, then start a fresh local store.
• If it differs and already occurs in $D$, reject the attempted return to a closed group.

The first record has no preceding group to check. The final right delimiter checks the last group’s already ready flag. No directory scan or population counter is needed to certify all groups.

The alias $v$ pays the local row lookup, and the actual suffix $w$ pays the local construction-75 update. In the routed contract, the intervening actual target prefix $E(b)$ is checked against the retained current store name; it does not substitute for any service that the local proof assigns to $w$. Local code width remains

$$m_b=\min(\ell_b,n_b)+d_k.$$

At the target endpoint, close the local row update and the already opened outer store-dictionary path with the new local tuple. These are a fixed number of nested coherent capsules, irrespective of the number of previously prepared stores. All key paths were traversed during their actual names; closure does not walk back through their lengths. The inherited coherent capsule and strict-queue contract is the same one used in constructions 71–75.

After each completed record, $D$ already contains the latest tuple. Thus switching names does not require inserting the preceding store through its old long name. A shorter new store name pays only its own lookup/comparison. If an equality stream ends before the old longer name, that endpoint establishes inequality without traversing the old suffix.

Each local producer starts from its fixed empty state and reads no other store’s support, birth order or pool. The stores may assign the same bits to different target names. This is harmless: no operation below treats cross-store code equality as literal equality.

4. Overlapping supports: bounded dependencies per source

Use the inherited literal source dictionary. A source header contains at most $p$ lanes. Each lane retains its store-name stream, frozen local-store tuple, committed selected union and one pending local row. The committed union is either EMPTY or a local omission list of at most $k$ code/word pairs, relative to that store’s $U_b$.

For a left record, the actual source $u$ retrieves its header and opens the outer source writeback path. The following actual $E(b)$ bits simultaneously:

1. retrieve the frozen store tuple from $D$;
2. compare $b$ with the at most $p$ retained lane names;
3. retain the incoming store name for a possible new lane.

The store-name terminator selects an existing lane or an unused one. Unknown stores reject. If all $p$ lanes are used and the name is new, reject even if the coming alias would be absent. These operations require only the current literal bits and a fixed number of readers. No name identity or address is observed.

The following local alias $v$ supplies $\ell_b$ actual bits of service. In the selected lane only, finish the old pending row’s omission extraction and intersection while routing the new alias in that frozen store. At the alias endpoint, commit the completed local union and install the looked-up row as the new pending row; an absent row contributes EMPTY. Validate the required alias width. A too-short invalid alias may leave unfinished speculation, but the machine permanently rejects that input, so it does not owe a reusable state for it.

Every other lane is unchanged. In particular a long pending operation in store $b$ is never charged to a following short alias from store $c$. If $b$ is never selected again, its pending row stays directly readable. This is why a single source-wide pending job would not justify the theorem when local widths differ.

At the final source pin, its actual name $a$ retrieves the fixed-size lane header. For each lane the target $q$ services the construction-75 literal support-minus-omissions reader and its pending row’s processed-trie/pending-word reader. All at most $p$ lane readers run in a fixed parallel batch. Let their Boolean results be $M_b(q)$. Product membership is

$$M_a(q)=\bigvee_{b\text{ in the source header}}M_b(q).$$

The Horn formula with the terminal pins is satisfiable exactly when this bit is false. No common support is required: a target absent from one store can be present in another. The union may have unboundedly many omissions relative to the union of all prepared supports; no global density gate is inferred.

5. Routed targets: unbounded dependencies per source

Replace the source’s fixed lane tuple by a persistent literal lane dictionary keyed by $b$. Each leaf contains exactly the local committed/pending state above, plus its frozen store tuple. Different sources may select arbitrarily many different stores.

The left source name $u$ opens the source path. Its actual $E(b)$ then pays both the global-store lookup and the source-lane lookup/open path. A missing lane is initialized to EMPTY; an unknown store still rejects. After the terminator, the actual alias $v$ pays that lane’s local pending work and row lookup. Its endpoint closes the lane and source capsules. The capsule nesting depth is fixed: growing the number of keys does not add more nested directories.

The final target’s actual $E(b)$ is now a query route. After the source pin has retrieved its lane-directory root, those prefix bits retrieve the selected lane. If absent, the product is false. Otherwise the following actual suffix $q$ services only that lane’s committed and pending literal readers. The constant per-symbol service budget depends on $k$, not on how many other stores that source selected.

Why is it sound to ignore them? Every global target reachable through a different store $c$ has the distinct prefix $1E(c)$. Prefix-freeness and literal inequality exclude it from $1E(b)q$. Thus only lane $b$ can affect this answer. This argument is a property checked in the ordinary input names. It neither reconciles local codes nor treats a semantic quotient as a physical index.

A query ending immediately after its shortest valid local suffix is covered: the routing prefix has already retrieved the lane, and the suffix reader is ready before its first bit. A wrong-width suffix or absent source/lane returns false membership by its own endpoint. No old lane is normalized at the final delimiter.

6. Persistence, local costs and boundary cases

The source and store dictionaries, code pools, pending rows and word streams are immutable. Every completed update retains prior versions. A lane always points into one frozen store’s coordinated rows, pool and window. Code recycling during a later independent store’s construction cannot change it. Selecting the same local alias bits under different store names keeps distinct intermediate variables and distinct lanes.

Store construction costs each actual $b$, then $v$, then $w$ its own work; left selection costs each actual $u$, then $b$, then $v$ its own work. These releases are ordered correctly: source state is ready before store-name routing, and lane state is ready before local alias service. In the routed query, source state is ready before the target’s routing prefix, and the chosen lane is ready before its suffix. All fixed-size endpoint batches, startup, malformed-input flags and final output belong to these budgets.

The extra dictionary nesting has constant depth. The number of live cursor fields per symbol is fixed: bounded by $p$ in the overlap case and independent of dependency count in the routed case. Each field follows only fixed-degree pointers or literal bit streams. All speculative and retained records are counted, including words used only to establish failed name equality. The inherited compiler therefore applies without increasing degree/radius with input size.

An observed store may have only one row; duplicates and a support birth on its final record are covered by construction 75’s ready gate. Unknown local aliases do not invent rows. Different groups may have radically different widths. The grouping check forbids reopening a store after its final density check; removing that restriction would require a separate mechanism for validating changed stores and retaining the appropriate versions.

7. Failed shortcuts and exact remaining boundary

Cross-store code comparison fails. Independent recyclable codes have no common interpretation. Two equal code words may denote different targets, and two different codes may denote the same overlapping target. Our construction avoids that operation rather than supplying an uncharged translation.

One global pending slot fails as a scheduling argument. A new short alias from another store need not provide the service window of the older pending job. Keeping one slot per lane preserves the latter’s literal answer until its own service returns. This is a failure of that proposed schedule, not a language lower bound.

Unbounded parallel readers do not follow. In the restricted opaque-bit interface where component $i$ exposes only its independent membership bit $x_i$, no prepared cross-component aggregate is available, and one probe reveals one bit, deterministic exact OR needs $s$ probes on the all-zero vector of $s$ components. Otherwise change an unprobed bit to one and obtain the same transcript with the opposite answer. Negative output requires ruling out every component under this contract.

This observation is compatible with locally dense rows: use local support $\{q,z\}$, select either row $\{z\}$ or $\{q,z\}$, and add an unselected support-witness row where necessary. Each selected row omits at most one local target. Membership bits can vary independently across stores. Literal target names, routing topology, control state, timing and addresses must not leak the unprobed bits in the oracle statement. A native builder could prepare an aggregate or an index, so this is not an unrestricted native-language lower bound. The routed construction is an explicit escape from universal fan-in through charged query relevance.

The theorem preserves the Lab’s controls. Replay pays for each traversal; shared ancestry alone does not service it. Affine-fragment joins retain their coordinate assumptions. Persistent causal sharing retains history but does not supply either directory routing or per-lane service. Coherent unary algebra does not itself implement these branching readers. Imported entry 129 retains its growing alphabet and conditional state/port bounds. No matching/positive-path interface extraction for arbitrary native storage is claimed.

Next decisive target: allow unbounded per-source dependence on stores with overlapping global targets, using an input-built query route that reaches only the relevant lanes or a paid aggregate. Begin with targets that belong to at most two stores, with arbitrary ordinary names and independent local codes. Determine whether bounded semantic overlap is enough to construct and access the necessary directory before a short final query ends. Charge ownership discovery, source filtering, updates and all unfinished work. Do not assume a supplied incidence directory. Arbitrary external-heap import, variable widths within one store and right-group reopening remain separate frontiers.

8. Evidence and status

The independent executable audit checks the separated state transitions and both literal query semantics against a direct relation oracle. It includes independent code assignments, heterogeneous widths, interleaved selections and retained versions. Host containers are finite semantic oracles, not native execution or timing measurements. The all-size native claim is the release-time and resource argument above, reviewed against the inherited primitives.

Assessment 223 records adversarial review, finite evidence and publication checks. This is one coherent construction with two readout contracts, counted once. It adds no root-ledger admission or external novelty claim.