Final diversity forces a future work window

9 October 2026. Assessment 178. Written completion-cost theorem, conditional scheduling consequence and two failed repair routes. The persistent final-two-profile recognizer remains open.

What this changes

The shared-predicate investigation left a timing question: when can the input pay for repairing a growing class interpretation? A small final diversity promise supplies part of the answer. If there are currently $d$ different row counts and at most $K$ may remain, the input must contain enough fresh pairs to merge those counts. The minimum is quadratic in $d$ for fixed $K$. Counting the repeated ordinary row names strengthens the forced future encoded length to order $d^2\log(d+2)$.

This gives a possible source of time for delayed classification even when target widths and name lengths are unrestricted. It does not construct the classifier. A worker must remain useful through intervening updates and avoid work proportional to absolute count magnitudes or all aliases. Explicit examples below show why both restrictions matter.

A row is the set of targets associated with one source name. Its count is the number of distinct targets; a count class groups rows with the same count. In the radial subclass, a row contains whole levels of binary words of selected lengths. Such completed radial profiles are determined by their cardinalities, as in the existing radial reduction. Therefore a final bound on their number implies the final count-class bound used here. Intermediate rows need not yet be radial; the literal radiality validator remains a separate obligation.

1. Exact completion cost for monotone named counts

At a completed right-record prefix, let the observed rows have nonnegative integer counts $c_v$. Subsequent fresh pairs increment one count by one; duplicates do nothing. Existing rows never disappear. Fix $K\ge1$, a constant of the intended language. Give each row a positive price $p_v$ per increment.

Let the distinct current counts be

$$a_1<a_2<\cdots<a_d, \qquad W_i=\sum_{v:c_v=a_i}p_v.$$

Consider the abstract completion problem: increment existing counts until they assume at most K values, paying $p_v$ for each increment of row v. There are no decrements or deletions. Introducing new rows cannot reduce the necessary cost for the existing ones.

Written theorem. The minimum cost is

$$C_K=\min_{\mathcal P}\ \sum_{[i,j]\in\mathcal P} \sum_{t=i}^{j}W_t(a_j-a_t),$$

where $\mathcal P$ ranges over partitions of $1,\ldots,d$ into at most K contiguous nonempty blocks. Set $C_K=0$ for an empty row set.

Proof. Take any final set of at most K destination values. Assign every current row to the smallest destination no smaller than its current count. This cannot increase its cost. All rows with the same initial count now choose the same destination, and these assignments form contiguous blocks of the ordered initial counts. Lower each used destination to the largest initial count in its block; feasibility is preserved and cost cannot increase. This gives a partition with the stated cost. Conversely, moving every row in a block to its largest initial count realizes that cost by legal unit increments. Both inequalities follow.

The theorem is an elementary ordered partition optimization applied to the current counter problem. It is not a claimed new clustering method. A finite oracle can compute it by

$$F(k,j)=\min_{0\le i<j} \left(F(k-1,i)+\sum_{t=i+1}^{j}W_t(a_j-a_t)\right),$$

with $F(0,0)=0$, $F(0,j)=+\infty$ for $j>0$, and $F(k,0)=0$. Prefix sums of weights and weighted counts give a conventional $O(Kd^2)$ arithmetic-operation algorithm. This is a semantic computation, not a native constant-cost integer or sorting instruction.

Literal input interpretation

With $p_v=1$, $C_K$ is the exact minimum number of fresh pairs for this abstract count completion. It is realizable by an unrestricted relation extension: choose enough new target names for each row. It need not be realizable by a final radial relation with the same minimum cost. Radiality and other language conditions can only increase the required work.

In the actual clause syntax (-01v,+1w);, a fresh pair costs $9+|v|+|w|$ input symbols. Targets are nonempty, so choosing

$$p_v=10+|v|$$

makes $C_K$ a lower bound on the remaining encoded input length. It is generally not exact: target spelling, duplicate records and other required syntax add cost. Every term here is charged to actual future input, with no padding, ready handles or supplied grouping. The partition is used in the proof only; the machine is not given it.

2. A sharp population-free pair bound

Write $d=qK+r$, with $0\le r<K$. Any completion has at least

$$B_K(d)=K\binom q2+rq$$

fresh pairs after this checkpoint. The expression is zero when $d\le K$.

Proof. Each occupied count has at least one row. In a block containing m distinct integer counts, the distances to its maximum are at least $0,1,\ldots,m-1$, so its cost is at least $\binom m2$. Among at most K blocks of total size d, the sum of these convex triangular costs is minimized by sizes q and q+1. One row at each of d consecutive counts, divided into balanced contiguous blocks, attains the bound in the abstract count problem.

In particular,

$$B_K(d)\ge \frac{d^2}{2K}-\frac d2, \qquad B_K(d)\ge \frac{d^2}{4K}\quad(d\ge2K).$$

For final diversity two, $B_2(2q)=q(q-1)$ and $B_2(2q+1)=q^2$. Eight current count classes require at least twelve more distinct pairs; sixteen require at least fifty-six. Multiplicities and wider count gaps only strengthen the actual bound.

This lower bound applies to every admissible continuation from the checkpoint. It does not say those pairs involve every existing row, that their keys are convenient for a particular repair, or that intermediate diversity decreases monotonically.

3. Ordinary names strengthen the available window

Let H(m) be the total of $10+|v|$ over the m shortest distinct nonempty binary names, with H(0)=0. This is the smallest possible total price of m distinct named rows. Counting the $2^\ell$ words of length $\ell$ gives $H(m)=\Theta(m\log(m+2))$. For exact finite calculation, if $s_L=2^{L+1}-2\le m<s_{L+1}$, then

$$H(m)=10m+(L-1)2^{L+1}+2+(m-s_L)(L+1).$$

The formula includes L=0.

Encoded-window bound. For every positive integer t with $Kt<d$, every final-K continuation has remaining encoded length at least

$$tH(d-Kt).$$

Proof. For each final destination, at most t distinct initial integer counts lie less than t below it. Across at most K destinations, at most Kt initial count classes can have a representative that moves fewer than t steps. Choose one row from each of the remaining at least $d-Kt$ classes. These are distinct ordinary names, and each requires at least t fresh pairs. Their repeated row names and fixed syntax alone cost at least $tH(d-Kt)$. Splitting a class between destinations does not defeat the argument: choose its least-moving row; if it moves fewer than t, the class lies in one of the same K short intervals.

Define

$$E_K(d)=\max_{1\le t<d/K}tH(d-Kt),$$

with an empty maximum equal to zero. Taking t near $d/(2K)$ proves

$$E_K(d)=\Omega_K(d^2\log(d+2)).$$

For example the useful threshold $d\ge4K$ leaves t at least $d/(4K)$ and at least $d/2$ selected classes. This lower bound does not require comparable name lengths, a minimum target width, a bound on total aliases or a growing alphabet. All earlier preparation stays charged to its own prefix and is not reused as fictional future credit.

Completion debt cannot disappear without paid updates

For the fixed existing row set and prices, one increment of row v satisfies

$$C_K(\mathrm{new})\ge C_K(\mathrm{old})-p_v.$$

Indeed, first performing that increment and then taking an optimal new completion is a legal old completion of cost $p_v+C_K(\mathrm{new})$. Adding an entirely new row cannot lower the completion cost of the old rows. Iteration therefore preserves every old checkpoint’s remaining-work lower bound, minus the actual prices already spent. Debt can increase sharply; no symmetric Lipschitz bound is asserted.

The coarser bound $E_K(d)$ is not itself such a local potential. For K=2, the explicit formula gives $E_2(8)=92$ and $E_2(7)=68$. Prepare eight singleton classes at counts 1 through 8, with the count-one row named 0, using only targets of a common width at least four. Adding its absent one-bit target 0 costs eleven symbols and merges the first class into the second. The d-only bound drops by 24, although exact weighted completion debt falls by at most 11. Thus replacing a retained work certificate by a newly computed d-only quota can discard unpaid debt. The checkpoint lower bound stays valid; a naive step-by-step potential using only d does not have the required decrement guarantee.

4. What the window would fund

Here is the precise conditional scheduling consequence. Suppose a checkpoint with d current classes launches a worker requiring at most $A E_K(d)$ bounded local steps, including its preparation, observations, routing and allocation. Suppose also that its pending state remains semantically sufficient through every intervening legal update, or that all such updates can be incorporated within the same charged budget. Then a fixed service rate greater than A per future input symbol finishes that work by every accepted final-K boundary.

The proof is simply the encoded-window lower bound. For fixed K, a suitably bounded $O(d^2\log(d+2))$ job can use the same conclusion above a fixed threshold; finite smaller cases require a separate actual implementation. The original input symbols fund the worker. It does not wait at EOF or add padding. A fixed service rate can be packed by the existing simultaneous-record compiler once the worker’s elementary pointer program is supplied.

The hypotheses are deliberately operational. The theorem does not supply d as a free integer, a sorted class list, a final partition, the worker’s initial handles, or a mutable current-class oracle. Its statement is not a completed native transfer. In particular, the snapshot worker cannot discard its progress on every later update and still charge each restart to the original window. Several outstanding workers cannot each spend the entire same input budget without a proved fixed-rate schedule.

The promising target is a class-local worker whose cost depends on count differences and distinct classes, with a readable update log or pending interpretation. The completion theorem provides a possible deadline certificate for that target. Maintaining the certificate or detecting its launch condition is part of the remaining construction.

5. Two tests that prevent an invalid transfer

Large absolute counts do not enlarge the debt

Completion cost is invariant under adding the same constant to every current count. A fresh worker that expands each absolute unary counter does not have this invariance.

For an actual radial example, use d distinct equal-length row names, with $d\ge2$, and choose $2^L\ge d$. Prepare row i with the first

$$2^L-d+i\quad(1\le i\le d)$$

targets of width L in lexicographic order. Complete every row to all width-L targets. This is a one-profile radial final relation, hence also within every K at least one. The continuation has exactly $\binom d2$ fresh pairs and encoded length

$$\binom d2\bigl(9+\lceil\log_2 d\rceil+L\bigr).$$

Every existing unary row counter already has length at least $2^L-d+1$. A protocol that newly releases d complete absolute-counter traversals at this checkpoint costs at least $d(2^L-d+1)$ dependent reads. For fixed d and any fixed service rate, this exceeds the continuation budget for sufficiently large L. All earlier preparation is real and charged, but precedes release of these particular traversals.

This rejects that fresh-expansion protocol. Prepared differences, maintained fingers, shared counter representations and earlier ongoing work remain possible. The useful window pays for coalescence distance, not arbitrary repeated inspection of historical magnitude.

A late restart cannot scan every alias

Fix $m=2^k$. Prepare m rows named $11u$, $|u|=k$, each with the complete width-one level $\{0,1\}$. Prepare row 10 with the complete width-two level, and row 0 with 00, 01, 10. The three occupied counts are 2, 3 and 4.

The single clause inserting 11 into row 0 has twelve symbols. It leaves exactly two radial profiles, counts 2 and 4. No other row needs to move. A newly released global alias rebuild costing even one operation per long row cannot be funded by that last clause for arbitrary m. At the right delimiter only fixed work is allowed; later endpoint names cannot retroactively satisfy that delimiter’s validation contract.

Thus a worker that restarts a scan of all names on this final class merge fails its deadline rule. A prepared summary, a class-local update or a directly readable pending correction escapes. This is not a language lower bound. It explains why the new d-dependent window must be paired with shared predicates rather than used to justify arbitrary name-dictionary rebuilding.

6. Surviving target and relation to the controls

The construction attempt remains incomplete. It now has a more informative acceptance test: preserve progress across monotone entry/leave operations; charge expensive work to forced future coalescence; depend on gap and class information rather than absolute counter expansion or all-alias refresh; and leave final diversity and late reuse directly readable.

The next decisive research test is a restart-free, gap-sensitive shared-predicate worker with a resource invariant tied to completion debt. It must explain how its launch condition and initial class information are obtained from ordinary input. If that cannot be done, retain a precise failure and attack a final-only certificate that avoids the all-prefix histogram service.

The fixed finite observation bank, mutable gap histogram, bounded-live profile repair and final-one-profile rectangle deficit are controls, not implementations of this worker. Earlier input-funded compilers use a last-publication work window; here the proposed source is mandatory future class coalescence. The common risk is stale compiled interpretation after a new update. Entry129’s imported relation-monoid and port results are unchanged. No matching-interface extraction or new scaffold-to-PEG transfer follows.

The finite checker compares the partition formula with exhaustive legal unit-move searches, checks weighted costs and encoded bounds, and constructs both deadline witnesses. These are finite semantic experiments. The formulas above have written proofs; the scheduler is conditional; the persistent service remains a conjectural construction target. No root claim, novelty judgment or major-result count is advanced.

7. Completion debt pays only for work already released

Assessment 180 revisits the queue and persistence proof mechanisms against the worker condition in section 4. The attempt was to freeze a class snapshot, compile it without restarts, and replay buffered updates before the final boundary. A linear total replay bound is insufficient. The following elementary scheduling calculation makes the remaining obligation exact.

Fix a worker lane offering $q$ elementary steps per input symbol, after reserving the foreground parser and output budget. At a checkpoint let $B$ steps be ready. At subsequent symbol $t$, let $a_t$ further steps become ready before that symbol’s service. Assume unfinished work always has a ready next step, service is work-conserving, and these steps include all maintenance, routing, observations and allocations. This is a specified worker interface, not an assumption that arbitrary pointer repairs have this property.

With $b_0=B$, the exact backlog is

$$b_t=\max(0,b_{t-1}+a_t-q).$$

Unrolling gives

$$b_T=\max\left(0,\ B+\sum_{t=1}^{T}a_t-qT, \max_{1\le r\le T}\left\{\sum_{t=r}^{T}a_t-q(T-r+1)\right\}\right).$$

Proof: substitute the preceding maximum in the recurrence and distribute addition; each reset to zero introduces exactly one new suffix term. Induction from $T=1$ proves the formula. Consequently the worker has caught up at $T$ if and only if both the initial-work inequality and every suffix inequality are nonpositive. This is the standard single-server workload identity, used here as a release-time diagnostic; no scheduling novelty is claimed.

The completion theorem supplies $T\ge E_K(d)$ at every accepted final-K boundary after a checkpoint with $d$ classes. It can pay the first term. It supplies no bound on a burst $a_T$ released at the final symbol. In particular, an amortized inequality $\sum a_t\le\alpha T$ does not bound every suffix. Unused service before a job is ready cannot be stored as completed work.

A sufficient correction interface

If each symbol releases at most a fixed $\alpha<q$ steps and $B\le(q-\alpha)E_K(d)$, the initial term is nonpositive at every accepted boundary and all suffix terms are nonpositive. Hence the worker is caught up by each such boundary. If work is created in finitely many lanes, reserve a fixed service rate for each or include their aggregate arrivals; the same input budget cannot be spent independently by arbitrarily many lanes.

The native transfer additionally requires an interpretation of every pending state. The completed snapshot, partial compiler, captured updates and already applied corrections must denote the actual current rows. An update must preserve this interpretation while allocating only bounded-degree nodes pointing into the permitted old-top neighborhood. Either internal queries have an exact bounded-cost reader for this pending interpretation, or the algorithm must prove it makes no such query before catch-up. A terminal acceptance flag and late selectors must be ready by their own deadlines. The workload calculation supplies neither this reader nor ordinary-name routing.

All constants, including degree, radius, service rate and finite control, must be fixed independently of the input, row population and target widths. Input is consumed in the displayed left-to-right record order; no end-of-input service is added. Initialization is fixed. Captured streams and retained versions count toward storage; a bounded-allocation implementation would retain only O(N) newly allocated nodes over actual encoded length N. Discovering d, the launch condition and the first worker roots is still charged. No recognition or PEG transfer is asserted; any later native recognition transfer must preserve input orientation, including the reversal in the scaffold-to-PEG direction.

This sufficient interface is stronger than section 4’s final total budget: it separates release density from progress preservation. A bounded burst can also fit a separately reserved fixed delimiter allowance. A burst proportional to an unbounded record length cannot.

Literal final-record witness against whole-record replay

For every $L\ge2$, let $U_L$ be all binary targets of length $L$, and set $z=1^L$. Prepare three ordinary rows:

$$R_{10}=U_L,\qquad R_{11}=\{0,1\},\qquad R_0=U_L\setminus\{z\}.$$

The current counts are $2^L,2,2^L-1$. Append the single clause (-010,+1z);, substituting the actual $L$ bits of $z$. Its length is $L+10$. The final relation has exactly two radial profiles, $U_L$ and $\{0,1\}$. There is no missing decompositional advice, padding or final pass. With $p_v=10+|v|$, the exact abstract completion debt just before this clause is 11: the optimal correction increments row 0 once. Moving the low row to another class costs at least 12, and all other choices cost at least 11.

Consider the particular protocol that makes a replay job available only after a complete fresh-pair record has been certified and then newly traverses its saved target spelling. It releases at least $L$ dependent old-storage observations at the clause delimiter. For every fixed delimiter allowance $q$ and fixed permitted lookahead allowance $c$, choose $L>q+c$. The protocol cannot finish before its required boundary output, although the original record itself supplied $L+10$ input symbols. Earlier idle service, an already completed snapshot and a bound on total replay work do not change this conclusion.

This is a protocol obstruction, not a native recognition lower bound. A parser may capture the traversal incrementally, prepare both fresh/duplicate outcomes, retain a current cursor, or use an already coherent class action. Those mechanisms are outside the rejected whole-record replay contract. If its output is allowed to wait for an unbounded subsequent pin, this particular deadline argument also no longer applies; the maintained problem requires the earlier delimiter output.

What the attempted composition still lacks

Freezing the source graph preserves the snapshot’s meaning, but does not make its answer current. Replaying the raw log after compilation repairs meaning only when replay has actually caught up. A real-time FIFO supplies cheap enqueue/dequeue of a ready record handle; it does not execute the record’s class action. DSST node copying supplies a different correspondence, with pointer repairs completed before the next public operation. Neither result provides a current class route through arbitrary immutable aliases while that repair is pending.

The proposed stronger operation is therefore a streamed class correction: consume ordinary names and capture all growing work while their symbols arrive; after fresh-pair certification, commit Enter/Leave and neighboring-gap effects with only fixed residual work; keep pending class interpretation and final selectors readable. No supplied bucket handle, version array, unbounded label, address comparison or pointer identity is allowed to stand in for this operation. Its initialization and launch test remain charged.

The next test is to implement that operation on the moving-row/untouched-alias family, first for one frozen compilation epoch. Account separately for work released during name traversal, work released by the fresh-pair decision and work released at class merge. A successful single epoch can then be tested for overlapping jobs and repeated epochs. The final-only K=2 certificate remains an alternative. This assessment does not close either route, transfer the diagram lower bound, or advance a native SAT/PEG claim.