Shared targets through a routed owner and bounded exceptions

12 October 2026. Written native construction 77. A sufficient composition criterion for independently prepared full rows; no root-ledger admission or external priority claim.

The investigation guide records the current frontier and links this construction to earlier mechanisms and their evidence.

Result and example

Unbounded source dependence and genuinely overlapping targets can coexist with immediate answers. Split each store’s row into targets whose ordinary names route to that store, and a bounded list of foreign targets. Keep routed activations shared. Materialize only the foreign lists, with one pending list preserving answers before that work finishes.

Consider a star. Name every edge with the center’s encoded name followed by an edge suffix. The center’s row contains all edges; each leaf’s row contains its one incident edge. Activating the center changes arbitrarily many answers through one routed bit. Activating a leaf contributes one materialized exception. Each edge is the same literal target in both stores. There can be arbitrarily many stores selected by one source. This differs from the disjoint namespaces in construction 76.

The naming condition is essential. This result does not solve the arbitrary-name graph test from assessment 225. It supplies a concrete mixed readout mechanism: one input-routed contribution plus bounded, input-paid scatter. No fractional-cascading implementation is assumed.

1. Exact checked language

Use the prefix-free binary encoding from construction 76: replace 0 by 00, 1 by 01, then append 11. Write it as $E(b)$, of length $e(b)=2|b|+2$; pair 10 is invalid. All displayed encodings expand to actual binary symbols. Sources, intermediate variables and targets have disjoint prefixes 00, 01 and 1.

Fix integers $d\ge1$ and $C\ge5$. Read right records, left records, then the two unit pins in the same explicit phase order and delimiters as construction 76:

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

Names $b,u,a,q,z$ are nonempty binary words; left alias $v$ is exactly 0 or 1. The sole observed right alias is 0; alias 1 is absent and contributes EMPTY. Selecting it never retracts a previous selection.

Require at least one right record. Its store name establishes a positive width $m$. Every subsequent right or left store name must have that width. Each store occupies exactly one nonempty contiguous right group; returning to a closed group rejects. Left stores must exist in the completed right directory. No bound is placed on source-name length, source count or the number of stores selected by a source.

Every right target must parse as $q=E(c)w$ with nonempty $c,w$ and satisfy $|q|\le Cm$. The decoded $c$ need not be a known store or have width $m$. The target is primary in store $b$ if $c=b$, and foreign otherwise. Every store has at most $d$ distinct foreign targets; duplicates do not consume another slot. Primary target counts are unrestricted. Target lengths can differ, even inside one store. These conditions are checked from ordinary fields; no owner annotation or decomposition is supplied.

Final target $z$ is any nonempty binary word. A malformed namespace, length exceeding $Cm$ or off-support word gives false membership, rather than a structural-input rejection. Only actually recorded right targets can be reachable. The accepted language consists of structurally valid formulas whose two pinned variables are not linked by the relation product, equivalently whose Horn formula is satisfiable.

An optional fixed ownership bound $D$ can be checked by the input-paid owner-name directory of assessment 224. It is unnecessary for the recognizer. Taking $D=2$ retains the graph specialization. The machine does not receive a graph orientation: the literal $E(c)$ target prefix supplies the routing condition.

2. The representation identity

Let $X_b$ be store $b$’s full row, $F_b$ its foreign subset, and $A_u$ the set of stores selected with alias 0 for source $u$. Define the static set

$$P=\{q:q\in X_b\text{ and }q=E(b)w\text{ for some }b,w\}.$$

For a parsable $z=E(c)w$, exact product membership is

$$M_u(z)=\bigl([z\in P]\land[c\in A_u]\bigr) \lor\left[z\in\bigcup_{b\in A_u}F_b\right].$$

For an unparsable $z$, the first term is false; the second is also false because foreign words were validated at construction. To prove the identity, divide each selected row at its literal namespace equality. A primary occurrence of $z$ can come only from store $c$. Every other occurrence belongs to its store’s foreign subset. Both implications follow, including targets that have no primary occurrence at all.

The static test $[z\in P]$ is necessary: activation of $c$ does not activate all words in its namespace. It is also useful. Its reader can start at the first target bit, in parallel with routing $c$. The final store lookup therefore creates no debt to replay the consumed target prefix.

3. Prepare the interface from right input

Use the Lab’s maintained literal dictionary primitive: one constant-view path step per actual key bit, an immutable forward word stream, and constant-size endpoint closure of the already opened path capsule. Pointer-valued payloads have a fixed number of fields. This is the serial dictionary contract used by construction 76, not a mutable backpatch or a free root lookup. Its strict FIFO and bounded simultaneous-record compilation are inherited; all their records and observations count here.

Maintain a global store dictionary and a primary-support dictionary $P$. A current store payload contains at most $d$ foreign word-stream pointers. Actual $E(b)$ bits retrieve/open the store path and compare the name to the preceding group. An existing nonpreceding store rejects, as in construction 76. A unary ruler built during the first decoded store name checks every later width. Fixed $C$ laps over this retained ruler bound each right target’s entire length, including its encoded namespace. A too-long target rejects when the bound is exceeded; no endpoint scan is required.

During the actual target bits, open its path in $P$, parse its namespace and compare the decoded $c$ with the retained current $b$. In parallel, retain a forward stream for $q$ and compare it with each of the at most $d$ existing foreign streams. End markers distinguish a proper prefix from equality. All readers start when $q$ starts. At its delimiter the parser, equality and length flags are ready.

If primary, commit membership in $P$. Otherwise discard that speculative membership change and append the retained stream only if foreign and not already listed; reject an additional distinct word beyond $d$. Closing the current store payload uses its already opened path, not a second traversal of $b$. A single fixed batch closes both paths. Old owner leaves need no pointer to a future final tuple.

The local foreign list is built only from the current group’s records. The global $P$ records literal primary support, not shared local row codes. Stores remain independent in their local preparation. No group-final work is required beyond its ready flags. After the last right delimiter the store directory and $P$ are frozen and directly available through the top header.

4. Source updates and the paid pending packet

For each source $u$, retain a fixed-field header $(B_u,T_u,H_u)$. Here $B_u$ is its persistent store-keyed activation dictionary, $T_u$ its committed target-keyed foreign membership dictionary, and $H_u$ a packet of at most $d$ foreign word pointers. Initially all are empty. The invariant is

$$\{z:T_u(z)\}\cup H_u=\bigcup_{b\in A_u}F_b, \qquad B_u(b)=[b\in A_u].$$

The actual source word opens/retrieves this header. During the following actual $E(b)$ field, run three fixed parallel tasks: global-store lookup, activation-key lookup/write preparation, and insertion of the OLD packet $H_u$ into $T_u$. Each insertion consumes its retained word stream in forward order, taking $O(|q|+1)$ local operations, including capsule closure. It does not reread an earlier input symbol for free.

The complete old packet requires at most a fixed primitive constant times

$$\sum_{q\in H_u}(|q|+1)\le d(Cm+1)\le d(C+1)m$$

operations. A fixed rate per decoded store bit therefore finishes it by the $E(b)$ terminator. Its constant depends on $d,C$ and the inherited primitive, never on $m$, row size or source history. Use sequential insertion into $T_u$; a completed insertion supplies the next root. The extra endpoint steps are included in the displayed $+1$ terms. The packet pointer list has fixed size, and the worker is released before the first store bit. Initial finite setup fits the fixed header budget.

At alias 0, set $B_u(b)$ to true and install the frozen store’s foreign packet as the new $H_u$. At alias 1, leave $B_u(b)$ unchanged and install EMPTY. In either case the old packet has already been committed. At the record endpoint close activation and source capsules in a fixed batch. There is no row-size-dependent work at the alias or final delimiter.

Interleaving other sources does not help or harm this proof: each source’s next own selection supplies the same positive width $m$. An unknown source starts empty. Repeated activation is harmless because insertion is idempotent. The final selection may remain pending forever; its bounded packet is directly readable. No end-of-input flush is needed. A malformed or short store field may abandon speculative work only after permanently rejecting that invalid input.

5. Late pins and exact negative answers

The actual source pin $a$ retrieves its current header. During every bit of target $z$, run the frozen $P$ reader, the committed $T_a$ reader, and equality readers for all words in $H_a$. At the same time parse the initial $E(c)$ and feed each decoded bit to $B_a$’s lookup. The decoded name terminator freezes the activation bit. The required nonempty suffix leaves the parser in an ordinary target state; even the shortest suffix needs no delayed lookup.

At the final delimiter output the complement of

$$\bigl(P(z)\land B_a(c)\bigr)\lor T_a(z)\lor[z\in H_a],$$

with the first term disabled when namespace parsing fails. Exact stream exhaustion decides equality and terminal membership. Off-support extensions, proper prefixes, unknown routed stores and absent sources are covered. All final observations concern already reached reader states. There is no owner-name discovery followed by an uncharged second search, and no replay after the endpoint.

Each header and every dictionary root belongs to one retained source version. Updating another source or continuing this one never changes an old activation bit, aggregate, pending stream or static support. The same proof applies when a retained version is later used as the starting header, with that branch paying its own subsequent service. The recognition language itself asks one final query; this persistence assertion describes the representation, not additional free input operations.

6. Native theorem and resource account

Theorem 77. For every fixed $d\ge1,C\ge5$, one deterministic native scaffolding automaton recognizes exactly the checked satisfiable language in section 1. The optional ownership-$D$ version has one such automaton for every fixed $D$. Store count, source dependencies, primary row degree and widths may grow with the input.

For the exact record syntax above, using construction 76’s fixed phase delimiters, the actual length is

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

The inherited phase delimiters contribute their actual fixed additional length. No padding term, supplied decomposition or preprocessing allowance occurs. Right work is $O_{d,C}(|b|+|q|+1)$ per record. Left work is $O_{d,C}(|u|+|b|+1)$, including the old packet. Pins cost $O_d(|a|+|z|+1)$. Preparation, discarded speculative paths, old-storage observations, retained streams, every dictionary path, routing, allocation, queued work and output are included. Logical work and retained storage are $O_{d,C}(N)$, or $O_{d,C,D}(N)$ with the ownership gate.

At every symbol only a fixed number of cursor fields, finite-state parsers and bounded-degree records are active. Dictionary nesting is fixed: source header then activation or target dictionary, alongside frozen global directories. The old top supplies all observations; a bounded batch allocates new logical records without modifying old nodes. The established bounded simultaneous-record compiler yields fixed degree, fixed radius, finite labels/control and input-independent initialization, with $N+1$ physical scaffold nodes after its fixed presentation change. Explicit pointer serialization has $O(N\log(N+2))$ bits. The last-symbol output has no EOF work.

This is one fixed automaton for fixed parameters, not a nonuniform family indexed by $m$ or the graph. Native recognition yields a PEG for the reversal of this entire checked language. No reversal closure or general SAT lower bound is inferred.

7. What this closes, and what it leaves open

The construction closes a mixed case beyond bounded fan-in or wholly disjoint namespaces: arbitrarily large routed rows can overlap bounded foreign rows while unboundedly many stores are selected. In the star example choose distinct store words of a learned width $m$, edge suffixes of length at most $m$, and literal targets $E(b_{\rm center})w$. Then $|q|\le3m+2\le5m$; leaf foreign degree is one and the center primary degree grows without bound. The positive example uses real names satisfying the gate, not padding added to arbitrary instances.

The naming condition is not free graph relabeling. An arbitrary existing target cannot be replaced by an endpoint-bearing word without changing the input language and its cost. Neither a bounded graph degree orientation nor two semantic owners alone proves that ordinary target bits reveal one endpoint. Targets shared only as foreign words are also allowed, but each store pays its bounded foreign packet.

Three failed extensions locate the next boundary. With unbounded foreign lists, one selection may release unbounded materialization work. With heterogeneous store widths, a later short selection may not fund the preceding packet. With arbitrary target names, a late inverse owner list still does not supply the selected source’s activation on time. These are failures of these schedules, not language lower bounds. Shared foreign predicates, length-band workers and earlier source-filtered routes remain legitimate escapes.

The next decisive target is the first of these: retain the literal primary-owner prefix and common store service width, but permit unbounded foreign incidence. Can input-built shared foreign predicates replace enumeration while remaining readable at the target deadline? Begin with two owners per target and no omissions. Keep arbitrary-name routing and heterogeneous service windows as separate frontiers.

8. Evidence and contribution

The independent finite audit compares immutable headers and literal query readers with direct relation semantics, including interleaved sources, alias 1, variable target lengths, repeated selections, retained versions and star families. Its host containers are semantic oracles. Abstract packet counters check the written service inequality; they do not constitute a native simulator or a timing lower bound.

Assessment 226 records adversarial review and the six-result reassessment. The new written argument combines established Lab dictionary and pending-reader primitives; the mixed routed/scattered interface is the claimed advance, without an external novelty assertion. Imported entry 129 keeps its growing alphabet and conditional matching/positive-path scope. No extraction into those diagram classes follows from this construction.

Replay is paid separately on each branch; affine joins retain their coordinate hypotheses. Causal sharing preserves histories but does not service the exception packet. Unary coherent algebra alone does not supply the branching dictionaries. Earlier native SAT results and all prior open frontiers remain intact.