Name weights do not pay for arbitrary class broadcasts

9 October 2026. Assessment 177. Written conservation and restricted repair arguments, with finite corroboration. This is a sustained test of the candidate in assessment 176, not a native recognizer or a general native lower bound.

Result and payoff

Name-weighted routing has enough static address capacity. It also has a useful monotone conservation law: at a fixed numeric count, each row contributes its name weight at most once over the entire history. The proposed obstruction from repeatedly reusing a short name therefore fails at a fixed count.

However, bounded address length does not maintain the interpretation of those addresses. A single ordinary 12-symbol clause can change a count-class observation on an arbitrarily large set of interleaved names. A correction protocol restricted to XOR tags on ordinary-name prefixes needs one operation per sibling pair. A shared Boolean predicate answers the same example with one changing bit. This isolates a real representation choice: current class predicates can share corrections that fixed name-prefix patches cannot express cheaply.

The remaining target is a persistent, name-readable growing family of class predicates, maintained under monotone row moves. Neither this static capacity argument nor the fixed-predicate escape supplies that service. Final-only diversity two remains open; the existing final-one-profile and bounded-live-profile controls remain intact.

1. Two conservation laws, and one invalid weight assignment

For every nonempty ordinary binary name v, assign

$$\omega(v)=2^{-2|v|-1}.$$

These are analysis weights computed from actual names, not machine-supplied advice. There are $2^\ell$ names of length $\ell$, so

$$\sum_v\omega(v)=\sum_{\ell\ge1}2^{-\ell-1}=\tfrac12.$$

A row’s count is the number of its distinct targets. Fresh pairs increment it by one; duplicates do nothing. Counts never decrease.

Fixed-count conservation. Fix a numeric count c. Count a row’s weight once when it first visits c. The sum over every row that ever visits c is at most one half, even over an infinite history.

Proof. A row can visit c in only one contiguous interval: after leaving for c+1 it never returns. The visitors are a subset of the distinct binary names. Apply the displayed sum. Repeated duplicate records during a visit contribute no additional mass. This argument concerns logical rows, not the number of persistent copies of their records.

Current-partition conservation. At any version, let $B_c$ be the nonempty class of rows currently at count c and let

$$\Omega(B_c)=\sum_{v\in B_c}\omega(v).$$

The classes are disjoint, so their total mass is at most one half. For any resident v, $\Omega(B_c)\ge\omega(v)$. Thus an ideal route charged to $1+\log_2(1/\Omega(B_c))$ would fit the proposed $2|v|+2$ bound. This is a numerical implication, not an implementation.

Failure of permanent creator weights. There is no corresponding global bound if every abandoned bucket keeps the weight of a short row that once owned it. Prepare distinct long-named rows $r_1,\ldots,r_h$ at counts 1 through h. Increment the one-bit row 0 from zero through h+1. When it leaves count i, $r_i$ keeps that bucket populated. If all h retained bucket proxies are charged $\omega(0)=1/8$, their assigned mass is h/8. It is unbounded.

The preparation is ordinary input: use a fixed target width sufficient for h+1 distinct targets, and insert the first i into $r_i$. This costs a quadratic number of pairs, with every name bit charged. The short row never returns to any count. Consequently this example does not contradict fixed-count conservation, and it does not rule out current-resident weights, ownership transfer, prepared fingers or a different proxy scheme. It rules out treating each old incarnation as if it independently inherited the same global Kraft budget.

2. Static short routes exist without knowing the count

There is an explicit coding argument that avoids invoking a data-structure theorem. In each nonempty current class choose a shortest resident, breaking ties lexicographically; call it r. Encode each bit 0 of r as 00, each bit 1 as 01, and append 11. These codes are prefix-free: payload pairs begin with 0 and the terminator begins with 1. Distinct classes have distinct representatives because their resident sets are disjoint.

For a query row v in that class, the code length is

$$2|r|+2\le 2|v|+2.$$

A finite binary trie of these codes therefore provides a bounded-degree static route to every current class with this length bound. Its number of nodes is at most one plus the sum of the code lengths. Finite edge labels and fixed degree suffice; no numeric count or address is read from a pointer.

This is only an existence construction for one given finite partition. Selecting representatives, building the trie, finding r from v, retaining versions and repairing it after a move have not been implemented natively. In particular, if r becomes available only at the last bit of v, traversing its entire code afterward misses a constant final-symbol deadline. A proof of short routes must be supplemented by a proof that the route is available and traversed while the original name arrives.

This distinction also defeats a simplistic ownership argument. Repeated short-owner departure does not force large static codes: the abandoned class can use its longer resident’s name. The missing operation is transferring or interpreting the old aliases without a scan or a late second lookup.

3. One short update with arbitrarily fragmented name support

Fix $k\ge0$ and put $h=2^k$. For each $u\in\{0,1\}^k$, use two long row names

$$a_u=1u0,\qquad b_u=1u1.$$

Use the separate one-bit mover name 0. The target universe is the four two-bit words 00, 01, 10, 11.

Prepare every $a_u$ with all four targets, every $b_u$ with only 00, and the mover with 00 and 01. The occupied counts are 1, 2 and 4. Append the single fresh clause inserting target 10 into the mover. Its count changes from 2 to 3; the occupied counts become 1, 3 and 4.

For a present row v define GapOne(v) to mean that the next strictly larger occupied count exists and differs from its count by one. Before the update every $b_u$ has GapOne true and every $a_u$ has it false. Afterward both are false. Thus the changing support among long names is exactly

$$S_k=\{1u1:u\in\{0,1\}^k\}.$$

The mover itself changes from false to true. It lies outside the leading-1 subtree and will not weaken the lower bound below.

With ordinary clause syntax (-01v,+1w);, each record has length $9+|v|+|w|$. Preparation has $5h+2$ distinct pairs and exact encoded length

$$N_0=5h(k+13)+24.$$

The trigger has exactly 12 symbols, independent of h. Repeating that trigger is a duplicate and changes nothing. Appending every target to every row is a common ordinary continuation for both states; both finish with one identical radial profile. As in assessment 176, this completion erases the intermediate difference. It gives no final-language lower bound.

Exact restricted repair theorem

Define a prefix-XOR service as follows. Its layout is the fixed ordinary-name prefix tree. A version has one Boolean tag for each prefix (only finitely many nonzero tags). Querying a name returns the XOR of the tags on its path. A repair primitive toggles the tag at one chosen prefix; charge at least one unit for it, even granting the prefix locator for free. No additional shared predicate, global selector of prepared trees, layout replacement, or bulk instantiation operation changes the readout. Those are stronger services, not implementations of this primitive contract.

Written restricted theorem. Any exact repair between the two states above uses at least h prefix toggles, regardless of preparation or the initial tags. On the leading-1 subtree, h toggles suffice.

Proof. Consider each sibling pair $(1u0,1u1)$. Every prefix common to that pair affects its two answers equally and leaves their XOR unchanged. Prefixes of other pairs affect neither. To change the pair’s answer difference, at least one of the two full-name tags must be toggled an odd number of times. The h pairs are disjoint, giving at least h operations. Toggling exactly the h names $1u1$ realizes the required change on the long names. The full service additionally changes the mover; the stated h bound is intentionally only a lower bound for the whole state.

For any fixed rate a, take $h>12a$. Even starting at the first trigger symbol, the record cannot fund all these operations by its last symbol. Giving free prefix locators and ignoring allocation makes this a stronger allowance than literal trie path copying. The bound therefore excludes eager prefix-XOR materialization by that deadline. Arbitrarily much earlier preparation cannot change the algebraic difference bound within this contract.

The qualifications matter. Selecting a precomputed after-state root, sharing a changing predicate among many paths, changing the name layout, or carrying an exact readable pending action all leave this contract. A pending action is not refuted merely because materializing its effect needs h patches. Neither overwrite tags with a different readout semantics nor arbitrary branching DAGs are covered. The theorem makes no claim about all persistent dictionaries or all native machines.

4. A constant shared gate escapes that witness

Let z be the bit saying whether the trigger has occurred. At either of the two prepared states, every present row has the following exact answer:

$$\operatorname{GapOne}(0)=z,\qquad \operatorname{GapOne}(1ub)=b\mathbin{\wedge}\neg z.$$

This readout scans the ordinary query name once, retaining its last bit and whether it is the mover. It reads one finite version bit. A persistent two-state service stores z in an immutable version root; the trigger changes it to 1 and a duplicate leaves it 1. Old roots retain their old answers. A fixed number of finite registers, fixed degree, radius one and bounded allocation per update suffice for this prepared two-state service, uniformly in k. It uses no pointer equality, address arithmetic, storage-size, timing or control-flow advice.

No whole h-bit vector is constructed at the trigger. The update changes one shared interpretation of the fixed predicate “long name ends in 1”. The preparation and query spelling are charged; the example is not an implementation of arbitrary row counts, arbitrary class membership or validation of the prepared family from unrestricted input.

This explicit escape explains why name fragmentation alone cannot prove the sought native impossibility. A general class service would need analogous predicates

$$P_c(v)=[\operatorname{count}(v)=c]$$

for a growing, changing family of c, with current successor-gap flags shared by all residents. Maintaining and routing those predicates is exactly the missing work. The fixed finite observation-bank construction of assessment 175 handles a fixed closed family; it does not automatically handle this growing one.

A fixed pending flag closes this witness because its predicate is already name-readable and never changes. The next meaningful test must include both a change to shared class metadata and a row’s entry into or departure from that class. Simply repeating the present witness would test the same fixed gate again.

5. Revised construction gate and failure ledger

A useful proposed service must provide all of the following together:

1. During an ordinary row name, identify its current class or carry a directly readable equivalent predicate state. No old handle is declared current for free.
2. On a distinct pair, move that row from c to c+1, including entry into an existing class and removal of a last resident. Duplicates are identities. Charge the distinctness decision, observations, routing and allocation.
3. Share a changed successor-gap interpretation across the current residents without scanning the possibly fragmented name set. Preserve old versions and avoid an unbounded cold correction chain.
4. Make the very next record readable on its own bit budget. A short route revealed at the delimiter, an aggregate weight bound, or a total amortized cost is insufficient.
5. Produce the final diversity gate and reuse selectors at the prescribed final-symbol deadlines, with no EOF drain, supplied decomposition, padding or parameter-dependent finite control.

The strongest surviving structural hypothesis is that one-visit monotone class membership permits a shared predicate representation with name-driven current-version access. Fixed-count conservation supports that hypothesis but does not prove its implementation. Test it on interleaved class memberships with short movers, and require the implementation to explain both class broadcasts and entry/leave operations. A successful construction would connect persistent sharing to the mutable histogram without importing matching-diagram restrictions.

If this service remains too strong, the alternative is a final-only diversity certificate that never exposes intermediate GapOne observations. The common one-profile completions above are a reminder that the internal service is optional for recognition. Final-only K=2, independent-store joins, the entry129 state/port bounds and the general SAT/scaffold boundary remain separate open targets.

Evidence and scope

The finite checker constructs literal relations and actual clause strings, compares direct count-neighbor observations, checks duplicate identity and common completions, and compares a dynamic-programming prefix cost with an independent exhaustive shortest-path search. It also checks code prefix-freeness and length bounds, monotone visits and the fixed-gate escape. Python maps, recursion and arithmetic are semantic experiment tools, not asserted native primitives.

These are written arguments and finite experiments supporting a failed construction attempt. No imported theorem is strengthened, no root claim is admitted and no major mathematical-result counter advances. The next target is the growing shared-predicate service above, or an explicit final-only replacement; it is not another survey of the completed Horn relation bridge.