Exact counter observations and persistent count classes

9 October 2026. Assessment 175, dedicated primary-proof review. Supporting written arguments and a mutable comparison construction; general final-two-profile native recognition remains open. No root admission or novelty claim.

Result and payoff

Two useful mechanisms emerge from the review. A finite family of linear observations closed under the input’s linear actions admits a native exact-zero monitor, even with unbounded counter values. For the radial-row problem, however, arithmetic on moments is unnecessary: an ordered histogram can maintain the exact number of different row cardinalities using only unit-stack edits and local links. The latter construction is mutable. Its missing persistent operation is current-version access to shared count-class metadata from ordinary row names.

This replaces the question “can a large variance be evaluated quickly?” with a sharper alternative: maintain a charged observation bank, or maintain coherent access to moving count classes. Neither is implied by small final diversity alone.

1. A sufficient criterion for exact negative observations

Fix a dimension $d$, a finite command alphabet $A$, integer matrices $A_a$ and integer vectors $b_a$ for each command, a fixed initial vector $x_0$, and a finite list $O$ of integer row vectors to be observed. A command updates $x$ to $A_a x+b_a$. All these data are fixed in the machine, not input advice. Suppose a finite set $L$ of integer row vectors contains $O$ and satisfies

$$\ell A_a\in L\qquad(\ell\in L,\ a\in A).$$

Then the vector of exact zero tests $[\ell x=0]$, for $\ell\in O$, has a deterministic native real-time monitor. Any fixed Boolean combination of those tests defines a native language of forward command words, hence a PEG for its reversal.

Proof. Maintain one counter $y_\ell=\ell x$ for each $\ell\in L$. For command $a$,

$$y'_\ell=y_{\ell A_a}+\ell b_a.$$

Thus the simultaneous update is a selection, with repetition, of old counters followed by bounded integer translations. The maximum absolute translation $B$ is a machine constant. Perform the simultaneous selection once, then at most $\max(1,B)$ rounds of unit translations, with no further selection. Vitanyi’s augmented-counter theorem implements each round in worst-case bounded time, including exact zero outputs. This is a fixed constant number of internal steps per command, not padding or additional input. Initial counter contents are fixed constants; alternatively initialize them by a fixed finite prefix of internal work.

Compile the resulting fixed real-time tape machine with the Lab’s persistent two-stack tape representation and simultaneous-record compiler. Tape moves inspect fixed neighborhoods; stack updates create boundedly many backward-pointing records. One fixed machine therefore has fixed degree, radius, labels/control and initialization; $O(1)$ old-storage observations, work and allocation per actual command symbol; and $O(N)$ retained logical records for encoded length $N$. The tuple compiler packs the fixed batch into $N+1$ physical scaffold nodes, with $O(N\log(N+2))$ explicit pointer bits. Every retained snapshot preserves the entire simulator state, including pending carry/copy work and the ready observation bits. No EOF drain, address comparison, uncharged preparation or growing register bank is used. This preserves snapshots but does not provide a join of unrelated snapshots: importing a counter from a separately prepared state still requires its own charged protocol.

All constants depend on the fixed command system and $L$. Letting $d$, $L$ or the command alphabet grow with an input parameter produces a family of machines, not one fixed native recognizer. In particular this consequence does not remove entry 129’s growing-alphabet or matching/positive-path qualifications.

This is an observation-relative representation. It need not encode unobserved coordinates of $x$. For example, $x=(p,q)$, the command $(p,q)\mapsto(p+1,2q)$, and observation $p=0$ have a singleton observation orbit despite growth in $q$. Coordinate copies, resets and unit increments give another example: with a permanent zero coordinate, all differences $e_i-e_j$ form a finite closed family, so pairwise equality of a fixed register bank is locally observable.

The condition is sufficient, not necessary. Finite-dimensional linear span is weaker than finite closure: for the shear $A=\begin{pmatrix}1&1\\0&1\end{pmatrix}$, the observations $(1,0)A^t=(1,t)$ are infinitely many despite spanning only two dimensions. That fails this counter-selection reduction, not native recognition in general. Restricting reachable states can make such an observation trivial.

Nor can a literal moment register be smuggled into the augmented-counter interface. Starting from fixed values, bounded copies and bounded translations make every register $O(t)$ after $t$ commands. A register required to equal $t^2$ after $t$ unit increments cannot be such a register. This excludes literal moment storage by that interface. It does not exclude an exact zero predicate represented differently; $(c_1-c_2)^2=0$ is already decided by one difference counter.

2. An arithmetic-free mutable histogram

Use the original ordinary right-first Horn encoding from Section 12.1. Exact lookup of each actual pair $(v,w)$ determines whether it is new. Each observed row $v$ has count $c_v\ge 1$. Only a distinct pair increments a count; a newly observed row begins at 1. Duplicate literals do nothing. No full cardinality is supplied as an input operand.

Maintain a doubly linked list of occupied count values in increasing order, with a permanent zero sentinel. A bucket for count $c$ contains:

• a stack representing its positive multiplicity;
• a stack of length $c-p$, where $p$ is the previous occupied count (or zero);
• its residue modulo a fixed $m$, if Section 51’s gate is wanted;
• previous and next links.

Each row dictionary leaf points to its bucket. Count values themselves are not stored as unbounded labels. Gap stacks and multiplicity stacks have finite labels and constant-degree links. The global number $D$ of occupied buckets is another unit stack. Optional $D_r$ stacks count occupied buckets of each residue, not rows.

For an existing row in bucket $c$, inspect the next bucket’s gap. If that gap is 1, its bucket is the destination $c+1$. Otherwise create a bucket immediately after $c$, with gap 1; if a next bucket exists, pop one unit from its old gap. The destination’s residue is $c$’s residue plus 1 modulo $m$. Increment its multiplicity and decrement $c$’s multiplicity. If $c$ becomes empty, unlink it and set the destination gap to one plus $c$’s old gap. This last update is a push, not arbitrary gap addition: the destination is always exactly one larger than the removed count.

For a new row, use the first bucket if its gap is 1. Otherwise insert a new first bucket of count 1 and pop one unit from the former first bucket’s gap, if present. Update $D$ and $D_r$ only on bucket creation/deletion. No existing gap needs a scan, multiplication, comparison of large integers, or addition of two arbitrary stacks. A gap equals 1 exactly when its tail is empty.

Induction on updates proves that buckets are precisely the occupied counts, multiplicities are correct, and each gap is the difference of adjacent counts. Every update changes a fixed number of records and stack roots. It performs $O(1)$ pointer work and $O(1)$ allocation, independently of population, counts, widths and their ratios. All stacks are built incrementally with $O(N)$ total allocation; stack-tail sharing needs no identity test. A mutable ordinary-name trie supplies row and pair routing during their actual input bits, so the whole control has $O(1)$ work per symbol and $O(N)$ storage. This is a finite-label pointer construction, not a unit-cost word-arithmetic claim.

At the right boundary, $D\le K$ is checked by inspecting at most $K+1$ stack cells, where $K$ is fixed. For Section 51, within-residue agreement is exactly $D_r\le 1$ for every residue, and the number of nonempty $D_r$ stacks is the occupied-residue count. Thus its variance-zero bit has a local mutable implementation with no moment evaluation.

More strongly, run the existing literal radiality validator separately. If $D\le K$, enumerate the at-most-$K$ bucket list at the boundary and assign its nodes distinct finite labels. This is fixed work, not a scan of the unbounded row dictionary. Later ordinary $v$ names retrieve the shared bucket’s label; left sources capture one frozen literal row root per label, and late $b$ bits query the fixed tuple as in Section 51. All label assignment is paid at the phase delimiter. This gives a mutable comparison control for the full final-$K$ radial family, including $K=2$ and arbitrary intermediate diversity.

3. The exact persistence gap

The histogram is not a native persistent theorem. Its buckets have bounded outdegree but arbitrarily many incoming row references. A multiplicity change or neighbor insertion mutates a bucket visible through every current row alias. Replacing that bucket by an immutable copy updates the list’s current root but leaves other row leaves pointing to old metadata. Blindly following such a leaf can miss the newly created adjacent count bucket. Comparing old and new addresses is neither a repair nor an allowed observation.

For a concrete witness, start with two rows a,b in the count 1 bucket. Increment a. The current histogram now has buckets 1 and 2, and b remains at count 1. In a shallow path-copy attempt, b’s retained reference can still show the former count 1 record with no successor. Incrementing b through that record creates a second count 2 bucket or uses stale multiplicity. Merely copying changed nodes does not keep the current histogram invariant. Earlier snapshots should retain the old record; current aliases must obtain a coherent interpretation without rewriting every row.

A sufficient service for the native transfer must therefore provide, on the same ordinary named-pair stream: exact distinctness; insertion and unit increment of named row counts; a ready final $D\le K$ bit (or the fixed-residue gate); and a name-readable final class selector coherent with the current snapshot. It must charge all routing, old observations, preparation, allocation and last-symbol output, with finite labels and fixed degree/radius. No ready handles, pointer equality or final row scan may be supplied. Given that service, literal radiality together with Section 51’s root-capture/readout completes the native final-$K$ language. This is a conditional interface reduction, not an implementation of the service.

The mutable construction isolates the required operation more narrowly than the moment worker. It does not establish a lower bound for persistence. Bounded-live classes in Section 49, final $K=1$’s rectangle deficit in Section 50, finite preinstalled palettes, and input-funded compilation in Sections 46-48 remain successful alternative mechanisms. Independent-store joins and the earlier causal/replay controls retain their separate hypotheses.

4. Next decisive test

Attack current bucket access after shared aliases become stale. First test whether a finite shared correction action can interpret old row references while the ordered count classes undergo unit moves and disappear. The key requirement is readiness at a short repeated name, not a final normalization of all rows. A construction must handle unbounded temporary buckets and arbitrarily many aliases; a failed route must isolate which relabeling or observation causes the debt.

The review does not justify treating generic equality signatures as a native primitive. Their production and comparison must be paid under this same contract. The finite observation-orbit theorem is a positive control for fixed banks, while the histogram is the stronger moving-class target.

Sources and evidence

The imported counter interface is Vitanyi, An Optimal Simulation of Counter Machines: The ACM Case, SIAM J. Comput. 14 (1985), 34-40, especially Section 2, Lemmas 1-2. The real-time zero-observation control is Seiferas and Vitanyi, Counting Is Easy, JACM 35 (1988), 985-1000. Persistent signature equality is compared in Mehlhorn, Sundar and Uhrig, Algorithmica 17 (1997), 183-198. Review 175 records the full-proof comparison and transfer boundaries.

The finite checker tools/research/check_count_class_actions.py compares the mutable histogram with explicit row counts and variances at 77,790 prefixes in 9,432 sequences. It checks 10,125 finite observation-lift transitions and an explicit stale-alias witness. Its maximum 18 instrumented update primitives is a bounded experiment on the mutable algorithm, not a native timing result or a count of all interpreter instructions. The general written proof supplies the constant pointer-operation bound. No new major-result count follows from these supporting controls.