Input-dominated class updates and reusable binary balls

9 October 2026. Assessment 181. Written native construction on a checked structural subclass. No root-ledger admission or novelty claim. The unrestricted final-two-profile radial language remains open.

Result and payoff

A shared class need not be accessed through an old bucket reference. If every class-changing update supplies a word long enough to traverse both the old and new class keys, the current class dictionary can be read while that word arrives. Immutable path capsules then commit the changes without rewriting any other row’s reference.

This observation yields a complete example. Fix integers $1\le K\le m$. In the ordinary right-first Horn encoding of the composition construction, section 12, require each nonempty final right row to be a binary ball

$$B_L=\bigcup_{j=1}^{L}\{0,1\}^j,\qquad L\ge1.$$

Require at most $K$ distinct final radii, and require distinct final radii to have distinct residues modulo $m$. Both conditions, and the ball condition itself, are checked from literal input. Target order within each row is arbitrary. Duplicates, arbitrary row interleaving, unbounded intermediate diversity, unrestricted name lengths and unrestricted left fanout are allowed.

Written theorem. For each fixed $m,K$, one fixed deterministic native scaffolding automaton recognizes exactly the encoded SAT instances satisfying these conditions. It reads the actual right records, then left records and the two ordinary late endpoint pins. Its degree, radius, control and labels are fixed; work and allocation per input symbol are bounded, including the final symbol. Preparation and retained history are charged to actual encoded length $N$.

For $m=K=2$, this includes two final balls of opposite radius parity, however far apart their radii are. It does not include every pair of radii. The native recognition theorem yields a PEG for the reversal of this checked encoded language. No reduction from unrestricted SAT or exact all-relation matching interface is claimed.

1. Existing primitives and the new update pattern

Use the already written pointer-valued serial dictionaries, strict persistent FIFO, complete-level counters and simultaneous-record compiler. These are inherited constructions, not new primitives granted for free.

A unary dictionary uses key $0^j$ for depth $j$. Its terminal payload and unary child are exposed by a bounded view, even for a retained capsule. A builder captures old terminal payloads into a FIFO while descending. Its final explicit tip and that FIFO represent the reconstructed path. Closing does not traverse the path backward.

We need a two-terminal variant. Suppose an actual word of length $n$ drives a descent and a unary ruler identifies a depth $\ell<n$ along that descent. Capture the frames above depth $\ell$ in one FIFO, save its terminal payload, and capture frames strictly between depths $\ell$ and $n$ in a second FIFO. At the delimiter, build:

1. an explicit depth-$n$ tip with its changed payload and unchanged child;
2. the middle capsule, or that tip directly if the middle FIFO is empty;
3. an explicit depth-$\ell$ node with its changed payload and the middle result as child;
4. the outer capsule, or that explicit node if the outer FIFO is empty.

Both capsule tips are explicit nodes. Their child pointers may reference another capsule; view exposes only one dictionary level and never recursively expands that child. The frame-fold interpretation proves that precisely those two terminal values change. There are two growing FIFOs but a fixed number of roots, queue operations and records per symbol. No path is replayed at the delimiter. This is a bounded-depth application of the existing capsule invariant.

The important hypothesis is temporal: the update word traverses the changed addresses before the deadline. Knowing that a short route exists after the word ends would not suffice.

2. Maintain the maximum-width histogram without aliases

Each named row retains its literal membership trie, a unary ruler for its current maximum width $\ell_v$ (zero for a missing row), and the finite residue $\ell_v\bmod m$. Store no reference to a mutable or supposedly current bucket.

Maintain a separate global unary dictionary $H$ whose payload at depth $j\ge1$ is a unit stack of size

$$M_j=|\{v:\ell_v=j\}|.$$

The depth-zero payload is permanently empty. Keep a global unit stack $D$ for the number of positive $M_j$, and $m$ unit stacks $D_r$ for the number of positive $M_j$ with $j\equiv r\pmod m$. These are counts of occupied widths, not row populations.

During the ordinary row name $v$, open its outer capsule and obtain the old row ruler. During each actual bit of target $w$:

• consume one old-ruler cell while available;
• advance one unary edge of the current global $H$;
• build one cell of the candidate new ruler and update its finite residue;
• traverse the literal membership and row-width dictionaries in parallel.

If $n=|w|\le\ell_v$, retain $H$, the old ruler and its residue. A short target causes no maximum-class change and needs no old-width bucket access.

Otherwise the first bit after the old ruler empties identifies the departure depth $\ell_v$. The two-terminal builder of section 1 has already captured the prefix to it and now captures the remaining path to $n$. At the delimiter, decrement $M_{\ell_v}$ for an existing row and increment $M_n$. For a new row skip the depth-zero decrement. Update $D$ and the appropriate $D_r$ when either population crosses zero. Empty and singleton stack tests are local. A target longer than the previous maximum is necessarily fresh, so no unbounded post-certification work is required.

Induction proves the histogram invariant: only the current row changes maximum, and both accessed populations belong to the same current global dictionary version. Two rows with the same old maximum retain independent identical-length rulers; neither ruler claims to be a current bucket. After one row moves, the other’s next class-changing target traverses the new global $H$ before making its own change. This is the escape from stale shared aliases.

A maximum may jump by an arbitrary amount. The longer target supplies all the traversed symbols. Count magnitude, row population and the number of old aliases add no work at the delimiter.

3. Check that final rows are balls

The maximum histogram alone does not establish row equality. Certify shape separately.

For each row, keep the existing unary width dictionary used by the complete-level validator. An occupied width has at least one distinct target. On the first target at width $n$, its predecessor and successor occupancy are available from the final path frame and one further bounded child view. Maintain one global unit stack $J$ counting all pairs $(v,j)$ with $j>1$ such that width $j$ is occupied in row $v$ but width $j-1$ is absent.

When a previously absent width $n$ becomes occupied:

• decrement $J$ if width $n+1$ was occupied;
• increment $J$ if $n>1$ and width $n-1$ was absent.

Every decrement is legal: the occupied successor was one of the counted violations. Other predecessor relations are unchanged. A duplicate or another target at an already occupied width changes neither condition. The finite distinction $n=1$ is tracked while the target arrives; no unbounded integer comparison occurs.

A finite nonempty set of positive widths has no missing predecessor exactly when it is $\{1,\ldots,L\}$ for its maximum $L$. Thus $J=0$ certifies contiguous occupied widths in every row.

In parallel, retain sections 35.2–35.3’s exact literal complete-level validator. Its immutable run counters increment only on distinct pairs and reach Full exactly at $2^n$. The first width-$n$ word constructs its capacity ruler on its own $n$ bits. A global unit stack $I$ counts occupied but incomplete row/width pairs. It is empty exactly when every occupied level is complete. This validator has no live-profile or width-span restriction; those restrictions belonged to earlier union constructions, not to this literal coverage check.

At the right boundary require $I=J=0$. Every observed row is then exactly $B_{\ell_v}$. Require additionally $D\le K$ and $D_r\le1$ for each of the fixed $m$ residues. These tests inspect only $K+1$ cells of $D$, two cells of each $D_r$, and the empty flags of $I,J$. They reject invalid shapes and colliding final radii regardless of the later SAT pins. Empty right input is allowed and has no nonempty row classes.

4. Compose and reuse the completed answers

Freeze the complete right dictionary at the phase boundary. A row’s finite residue is now an exact class label: the histogram gate implies that two rows carrying that residue have the same radius, and the ball gate implies they have the same literal target set.

Use section 51.2’s finite-selector receipt. Each left source $u$ holds an $m$-bit selected mask and at most one frozen literal row root per residue. The ordinary $u$ opens its capsule; the following ordinary $v$ retrieves its residue and row root in the frozen right dictionary. Capture that root if its residue has no representative yet. Missing intermediates add nothing. Duplicates and unlimited fanout require no additional slots. Close the suspended source capsule in bounded work.

During the positive source pin $a$, retrieve the fixed-size receipt. During the negative target pin $b$, traverse its at most $m$ row roots in parallel. Their terminal OR is exactly $(RS)(a,b)$. Complement it for SAT at the final semicolon. A long frozen row selected by a one-bit name never has to be scanned; the actual target pin drives membership lookup. No final global representative scan or row relabeling occurs.

This is serial right-first reuse through actual left input. It does not supply a constant-cost join of two arbitrary independently stored versions. The independent-store join frontier remains separate.

5. Full resource and observation contract

One machine is fixed for $m,K$. The alphabet is the ordinary binary-name Horn syntax of section 12.1, with nonempty names, right records before left records, and the two late pins. All punctuation and phase checks remain in the finite controller. Malformed or stopped partial input rejects. The right gate is ready at its boundary, and the SAT answer is ready at the final symbol. There is no EOF drain.

Initialization consists of empty dictionaries, queues and unit stacks plus fixed finite control. Per bit there are a fixed number of capsule views, FIFO operations, stack operations and finite-label updates. The two-terminal histogram commit has a fixed number of records, independent of both radii. Raw pair checking, predecessor-hole checks, complete-level counters, suspended outer paths, speculative short-target paths, discarded rulers, old versions, receipt allocation and output are all included.

Consequently there are machine constants $s,A,q,r$ bounding roots, allocation, fields and old-address radius in the simultaneous-record program. Its compiler gives degree $\max(1,s+Aq)$ and distance at most $r+1$, with finite labels/control and old-top update semantics. Actual length $N$ pays $O_{m,K}(N)$ retained logical records and exactly $N+1$ physical scaffold nodes, including the base; explicit pointer serialization uses $O_{m,K}(N\log(N+2))$ bits. No computed radius or growing count is a label. No pointer identity, numerical address, allocation-size, metadata, timing or control-flow side channel is observed.

The prototype’s Python maps and integer oracles are not charged native operations. Native routing and arithmetic are supplied by the specified capsule, stack and run-counter constructions. Finite experiments check semantic invariants and the new two-terminal kernel; the written schedule supplies the all-length resource proof.

6. Scope, controls and the next test

For any $h$, initially give different rows one target at widths $1,\ldots,h$. There are $h$ different current maximum classes. Subsequently fill rows to balls of two chosen opposite-parity radii above $h$. Both final profiles can occur. The checked theorem accepts this family despite unbounded intermediate diversity. It therefore uses neither the bounded-live gate of section 49 nor the final-one-profile gate of section 50. Arbitrary row-name/target-width ratios and target order distinguish its hypotheses from the span-based compilation controls.

The update dependency is the useful structural feature: a maximum changes only when its triggering word reaches farther than the old key. A minimum can instead change from a huge width to one on a one-bit target, so this specific access-dominance proof would not apply. That is a limitation of the criterion, not a lower bound for all minimum representations.

The finite residue restriction is also real. Balls of radii $L$ and $L+m$ are distinct but collide under the labeler and are deliberately rejected. Removing that condition requires a name-readable final selector or a way to combine ball predicates without such a selector. The histogram already detects arbitrary final radius diversity; the remaining unrestricted-two-ball obstacle is reuse labeling, not maintaining these maximum classes.

Next: test whether final two-ball reuse can avoid the fixed residue labeler, while preserving arbitrary short intermediate names and immediate source-receipt updates. Do not return to whole-record replay or cold bucket repair for this subclass. The broader arbitrary-radial two-profile problem and entry 129’s exact relation-monoid/port bounds remain unchanged.

The kernel is an extension of the existing serial-capsule construction, and the recognizer combines that extension with the existing literal-coverage and finite-selector mechanisms. This is a proof extension of known persistent scheduling methods at the stated native contract. It is not an originality claim for capsules, queues, counters or finite selectors.

The finite checker tests the kernel, gaps in occupied widths, arbitrary order, duplicates, old versions, residue collisions and late composition against direct set semantics.