Current count classes require version-aware routing

9 October 2026. Assessment 176. Written interface reduction and failed-route analysis, with finite corroboration. No general native lower bound, new native recognizer, root admission or novelty claim.

Result and payoff

The mutable count histogram from assessment 175 cannot be made persistent by keeping arbitrary old bucket references and adding a constant-cost correction after row lookup. Even monotone unit increments can encode independently changing answers at untouched bucket references. The existing stable-handle theorem gives a logarithmic worst-case correction cost in that precise interface. A fixed finite correction algebra also fails: its observable quotient must contain a Boolean deletion semilattice of unbounded rank.

This closes the proposed lookup first, repair the old bucket at the delimiter architecture. It leaves a concrete way forward: route through the current version while the ordinary row name is arriving, or maintain a directly readable pending interpretation that avoids current buckets. Name lookup and version correction must share the input budget. Neither small final diversity nor enough total historical input supplies this protocol automatically.

The result concerns a stronger internal service than final Horn recognition. The witnesses below can all be completed to one final radial profile. The existing final-one-profile recognizer already shows why an obstruction to this internal service is not an obstruction to the language.

1. A monotone family with unchanged probe rows

Fix $h\ge1$. Use 2h distinct row names $p_i$ and $m_i$, all of length

$$k=\lceil\log_2(2h)\rceil,\qquad 1\le i\le h.$$

Choose one target width

$$L=\lceil\log_2(4h+3)\rceil.$$

Prepare $p_i$ with $4i$ distinct targets and $m_i$ with $4i+1$ distinct targets, all of width L. For every $m_i$ designate one already present target $d_i$ and one absent target $f_i$, also of width L. This preparation is an ordinary right-factor clause stream (-01v,+1w);; the numbers and the decomposition are not supplied to the machine. The prepared relation has exactly $4h^2+5h$ distinct pairs. Its encoded length is

$$N_0=(4h^2+5h)(9+k+L).$$

For a subset X of $[h]$, append one clause for each $m_i$ in fixed increasing order: use $f_i$ if i is in X and $d_i$ otherwise. Every resulting history has exactly the same encoded length, and the same number and lengths of row and target names. In the resulting state,

$$c(p_i)=4i,\qquad c(m_i)=4i+1+[i\in X].$$

No other row has count $4i+1$. Let $G_i$ be the service observation “the next occupied count above $p_i$’s count has gap one”. Then

$$G_i(X)=1-[i\in X].$$

All h probe rows and their original bucket references are unchanged. The answers vary independently solely because other rows move. This uses precisely the neighbor test needed by the histogram when $p_i$ is incremented; it is not a demand to read arbitrary hidden implementation bits.

The construction uses $\Theta(h^2\log(h+2))$ actual input symbols, including preparation, and $h(9+k+L)$ symbols for the equal-length distinguishing suffix. There is no parameter-dependent alphabet: only ordinary binary names and the fixed clause syntax. One growing family of examples is tested against one fixed candidate machine. The construction itself does not establish any native time or allocation bound.

Final radiality does not exclude these prefixes

Append, for every one of the 2h rows, every target in $\{0,1\}^L$. This is the same continuation for all X; repeated pairs are permitted and change no counts. Every final row is now exactly $\{0,1\}^L$. Thus every prefix above has a common completion satisfying literal radiality and final diversity one, and hence also final diversity at most two. The completion costs 2h times $2^L$ ordinary clauses and is charged in full.

This does not transfer the intermediate $G_i$ observations to the final SAT bit. The common completion actually erases their differences. It shows only that an internal service required at every right prefix cannot dismiss these states as incompatible with a small final diversity promise. A final-only validator is free to avoid $G_i$ entirely.

2. Exact finite corrections contain an unbounded semilattice

Let $u_i$ denote the ordinary clause inserting $f_i$ into $m_i$. Repeating $u_i$ is a duplicate, so its observable action on this family is idempotent. Distinct $u_i$ commute on the relation. For a word w over these clauses, its vector of G observations depends exactly on the set of indices occurring in w. Concatenation acts by union of these sets.

Consequently any exact compositional summary for these updates, with all $G_i$ readouts, has the Boolean union semilattice on $[h]$ as an observable quotient. There are $2^h$ distinct summary classes. To prove this without assuming representation-level commutation, choose two distinct subsets, an index in their symmetric difference, and its $G_i$ test. Their summaries must differ. Repeated and reordered words may still have different physical representations; quotienting by this exact observation vector yields the semilattice.

In particular, a pending-correction scheme that stores all version-varying information in one member of a fixed finite set T, and interprets each unchanged probe handle from that member, requires

$$|T|\ge 2^h.$$

A fixed number of finite tags only replaces T by a fixed finite product and does not help. A finite set of generators is not a finite set of accumulated actions: an unbounded correction word or a dictionary can hold these $2^h$ cases, but its construction and access must be charged.

This is the exact mismatch with the augmented-counter mechanism in assessment 175. There the number of tracks is fixed, and arbitrarily many delayed selections collapse into a fixed finite transformation monoid. Here the number of independently changing metadata observations grows with the input. No claim is made that entry 129’s full relation monoid or its exponential port bound has been realized in this smaller semilattice argument.

3. Logarithmic repair after cold handle acquisition

Adopt exactly the identity-blind immutable pointer interface of the existing stable-handle theorem. Degree $D\ge2$, labels, finite control, register count and number r of version roots are fixed. Old records never gain forward links. A query may follow fields, test finite tags or null, copy pointers, allocate bounded records and branch on observed finite data; all operations are charged. Non-null pointer equality, numerical addresses, mutable ambient tables and version-dependent caller advice are excluded.

After preparing the common prefix, retain a fixed handle $H_i$ to each $p_i$ bucket. Require a cold operation GapOne(V,$H_i$) that returns $G_i$ in the selected current version V, without refreshing $H_i$ first. All construction and update work may be arbitrarily large and finite. In particular, this lower bound does not rely on an input-time or storage bound for preparation.

Written reduction. For h unchanged handles, the worst-case work of GapOne is $\Omega(\log(h+2))$.

Proof. The $2^h$ descendants from section 1 realize every h-bit answer vector on the same handles. The stable-handle proof therefore applies directly; arbitrary repeated Set operations are unnecessary. More explicitly, if every query takes at most q normalized pointer primitives, the r root unfoldings through depth q contain at most

$$W_q=r\sum_{j=0}^{q}D^j$$

finite tag positions. If A bounds the label alphabet and F the finite metadata states, there are at most $F A^{W_q}$ observable version types. Two equal types give identical executions with each fixed $H_i$, even with adaptive negative tests and query allocation. Correctness requires

$$2^h\le F A^{W_q},$$

hence $q=\Omega(\log(h+2))$. This is the previously written stable-handle argument applied to the ordinary count updates above, not a new lower-bound method.

The communication interpretation transmits only finite metadata and unfolded tags. It transmits neither pointer names nor sharing identities, allocation counts, inaccessible storage sizes, execution time, control-flow traces or query-specific cache contents. Handles and initialization are fixed before X is selected. An implementation that exposes any additional channel is outside this reduction and needs a separate argument.

Exactly which native architecture this excludes

Suppose an ordinary-name row lookup returns only an unchanged old bucket handle, and all current-version interpretation starts afterward at the row delimiter. A fixed per-symbol deadline leaves only constant work at that delimiter. That architecture cannot implement GapOne for all h under the stated interface.

The lower bound does not apply if parsing the name has already navigated the current correction structure, refreshed a query cursor, or produced a query-specific ready answer. The name length in the witness is $k=\Theta(\log h)$, precisely enough to fund the lower bound at constant work per bit. A current-root bit trie can answer the abstract $G_i$ query in $O(k)$ work when the ordinary name itself specifies the trie route. That is a positive access control; producing and updating such a route for arbitrary changing count classes remains the missing problem. Conventional path copying after a key is fully read is not by itself a native deadline proof.

Thus the required service must fuse ordinary-name routing with version interpretation, or avoid the histogram interface. Treating the row-lookup cost as paid and then declaring the returned old handle ready is the invalid step.

4. Total input length does not fund each numeric lookup

A second attempted implementation stores the histogram in a persistent dictionary keyed by the binary count c. Ordinary row lookup retrieves a local counter; an independent root-to-leaf lookup by c then costs $\Theta(\log(c+2))$. Total distinct-target input can plausibly pay that much work in aggregate: among c distinct nonempty binary targets, the sum of their lengths is $\Omega(c\log(c+2))$. This is a storage/work budget observation, not a deadline schedule.

Here is a specific failure of the eager full count-key traversal protocol. Fix a one-bit row name. First insert $C=2^L$ distinct targets of width $L+1$. Reserve all nonempty targets of lengths at most $m<L+1$. Then append $q=2^{m+1}-2$ of those reserved targets, in increasing length order. Every appended pair is new. All late counts are at least C, but the whole late suffix has exactly

$$B_m=10q+\sum_{j=1}^{m}j2^j =10q+(m-1)2^{m+1}+2$$

input symbols. If the implementation starts a complete count-key walk after each distinctness decision, it releases at least $q(L+1)$ dependent edge traversals during this suffix. For any fixed service rate a, choosing L so $q(L+1)>aB_m$ leaves unfinished work at the suffix deadline, even if every suffix symbol could be used for it. At the single-record deadline the problem is already stronger. Past target bits precede release of these particular walks.

This refutes the stated work-release rule only. A prepared successor table, a maintained finger, speculation before distinctness is decided, shared batched work, and directly readable pending updates do not satisfy that rule and remain possible escapes. One cannot forbid such preparation merely because the queried count is large. In particular the example is not a lower bound for arbitrary persistent dictionaries or native recognition. All previous long input, allocated records, speculative tables and old snapshots remain charged to their own actual histories.

The example explains why a proof must give both a total work bound and a release/deadline argument. Replacing current bucket access with an O(log c) dictionary is not sufficient unless that access is pipelined, accelerated, or charged to the actual incoming names.

5. The surviving concrete target

Use the following strengthened acceptance test for a proposed count-class service:

1. Start from the fixed empty state and the ordinary forward right-factor stream, with no supplied handles, counts, decomposition or padding.
2. During the bits of v and w, carry a current-version interpretation of v’s bucket, rather than waiting until an old handle has been returned. Charge the route’s stored name, preparation, old observations and allocation.
3. At the distinct-pair decision, create an exact readable pending move by one; duplicates must not move it. A pending move may defer physical repair only if the very next short record can already observe the correct semantics.
4. Preserve all old snapshots. Handle merges into an existing count and disappearance of a singleton bucket without an alias scan, stale epoch, uncharged pointer comparison or unbounded action word.
5. Maintain the final diversity gate and name-readable selectors by their actual delimiter deadlines. No final row scan or EOF drain is allowed.

The next candidate is a name-weighted proxy structure: charge a bucket’s current route to the ordinary names of its users, and drive that route while those names arrive. Test it first against a short row that repeatedly leaves populated buckets behind. A single permanent proxy slot owned by that short name cannot simultaneously name all the abandoned buckets; an epoch chain must either have a proved name-length bound or an explicit deamortized current route. This is a proposed test, not another proved lower bound.

A quantitative candidate uses the fixed name weights

$$\omega(v)=2^{-2|v|-1},\qquad \sum_{v\in\{0,1\}^+}\omega(v)=\tfrac12.$$

The proposed bound is a current-version route of length at most $a(1+\log_2(1/\omega(v)))=a(2|v|+2)$, with one fixed a independent of the number of rows, their counts and the retained history. These weights are determined by the actual names, not supplied advice. This is a target contract, not a proved data structure. Even achieving the total route bound would not suffice if its traversal begins only after the last name bit: a construction must show prefix-driven progress or an exact pending answer at the delimiter. The fixed-handle lower bound is compatible with this target, since h equal-length names already provide logarithmic time. The unresolved issue is producing and maintaining those routes through class moves and mergers.

The controls remain important. Fixed-bank observation closure compresses a genuinely fixed action family. Bounded-live profile repair has a fixed current palette. Final K=1 avoids current class discovery through a global rectangle deficit. Replay slices, affine-fragment joins, causal algebra and unary cubical algebra retain their paid navigation and separate interface hypotheses. None supplies an arbitrary cold live-handle refresh for free. Final-only K=2 and independent-store joins remain open; no scaffold-to-PEG transfer is made here.

Evidence and status

Python checker independently constructs literal relations, compares bucket-gap observations with the intended Boolean vectors, exercises duplicate/reordered deletion words, checks the common radial completion, and checks the exact encoded-length and deadline formulas. A separate finite binary-trie control checks retained versions without treating Python integers, maps or tuple operations as native instructions.

This is a completed unsuccessful attack on two concrete transfer routes, with a useful interface conclusion. The semilattice and stable-handle reductions are written arguments; finite enumeration corroborates them. The next construction must exploit the name-reading interval or avoid the service. Neither a new major mathematical result nor a native impossibility is claimed.