Threshold screening before persistent minimum readout

10 October 2026. Assessments 192 and 193. Written conditional scheduling/readout arguments, restricted failed routes and finite experiments. This note retains the conditional and failed-route stages; the sparse-age successor completes the native suffix specialization. No new root admission or novelty claim.

Current continuation: Section 9 links the completed sparse-age suffix construction. Ordered suffix reuse subsequently extends the construction to every fixed number of final maxima. Sections 1-5 preserve the original screening argument; Sections 6-8 record the joint reduction and failed directory attempt that led to the new representation.

Result and its limitation

Ordinary names can pay for short-threshold screening without the exponential name/minimum restriction of theorem 60. In an abstract scheduler that always advances a least-observed unfinished endpoint, the work still needed to screen every endpoint through digit depth $k$ is bounded independently of the number of selected rows. This isolates a possible way around the FIFO failure.

In this abstract screening argument, the scheduler is an explicit extra interface assumption; bounded local immutable updates are not supplied here. Nor does screening automatically maintain the minimum of the endpoints already completed. The finite experiment deliberately uses uncharged Python selection and completed-set oracles for these two operations. The claim is a work bound conditional on that scheduling discipline, not a removal of theorem 60’s native language restriction.

The goal at this stage was exact selected-union membership for frozen common-maximum suffix rows $[b_v,H]$. An answer at length $n$ needs either a selected witness with $b_v\le n$, or coverage of every selected row by evidence that its threshold exceeds $n$. The common upper ruler remains independently necessary. This stage does not handle varying maxima or independent-store joins. The later constructions establish common-maximum reuse and then fixed final maximum diversity; growing diversity and independent-store joins remain open.

1. A precise abstract screening interface

Each distinct selected nonempty ordinary binary name releases one job at its delimiter. An absent or empty right row releases no endpoint job. Job $v$ has a prepared canonical binary numeral for its positive endpoint, of length $\ell_v$, and an attained digit count $a_v$, initially zero. One abstract observation reads one next digit, advances its private cursor and detects numeral exhaustion. Fixed local implementation constants are normalized into the service rate; no integer length oracle is required for that digit operation.

Service always chooses an unfinished job of minimum attained count. Ties may be arbitrary. A completed numeral leaves the pending set. During each subsequent name of length $d$, grant $qd$ service steps before its new job is released, for fixed positive integer $q$. Duplicate selections do not release another job, although their input can provide service. No query arrivals are allowed: a query forks a frozen selected version.

This contract grants the choice of least-attained job, removal/insertion of its cursor and detection that every pending job has attained at least $k$. These grants are the implementation obligations, not consequences of the existing strict FIFO. A returned completed descriptor also needs a separately charged consumer.

2. Truncated debt is bounded by the name supply

For any positive integer $k$, define remaining screening debt

$$V_k=\sum_{v\text{ pending}}\bigl(\min(k,\ell_v)-a_v\bigr)_+.$$

Whenever $V_k>0$, some pending job has attained fewer than $k$ digits. A minimum-attained job therefore also has attained fewer than $k$ digits, and one observation reduces $V_k$ by exactly one. Completed jobs contribute zero. A release adds at most $k$. Consequently, at distinct-name release boundaries,

$$V_k^{(i)}\le\max(0,V_k^{(i-1)}-qd_i)+k.$$

Consider the last busy period for this truncated debt. Its first release costs at most $k$; each subsequent release can increase the residual by at most $(k-qd_i)_+$. There are at most $2^d$ distinct binary names of length $d$. This proves the conditional screening bound

$$V_k\le B_q(k):=k+\sum_{d\ge1}2^d(k-qd)_+.$$

It holds at every selection boundary and at the start of a query fork. Extra symbols and duplicate records can only decrease the debt. After query start there are no arrivals; exactly $V_k$ further observations suffice to screen every pending endpoint through depth $k$ under the assumed priority rule.

For a convenient uniform bound put $L=\lfloor(k-1)/q\rfloor$ and write $k=qL+r$, where $1\le r\le q$. If $L\ge1$, reversing the finite sum and bounding its geometric tails gives

$$\sum_{d=1}^{L}2^d(k-qd) \le 2^L\sum_{j\ge0}2^{-j}(r+qj) =2^L(2r+2q)\le4q\,2^{k/q}.$$

For $L=0$ the sum is empty. Thus $B_q(k)\le k+4q2^{k/q}$. At $q=4$ and $k\ge4$,

$$B_4(k)\le36\,2^{k-4}.$$

Indeed, after division by $2^{k-4}$, the first term $k2^{4-k}$ is at most 4 and decreases, while the second is $256\,2^{-3k/4}$, at most 32 and decreasing. A query phase starting at position $T_k=2^{k-4}$ with 64 abstract observations per actual target bit would finish before $2T_k$. This is a conditional observation schedule only; frontier maintenance, completed-minimum aggregation and reader alignment have not been included by assumption.

The linear cost through digit depth $k$ is substantive. Replacing it by a generic $C(k)=k\log_2(k+1)$ cost in the same name-counting calculation yields an estimate exponential in $C(k)/q$, which need not fit a $2^k$-scale deadline for any fixed $q$. This does not prove that every implementation with such an overhead fails; it shows that the present proof cannot absorb it uniformly. The next frontier must supply a joint linear truncated-work bound, or a genuinely stronger charging invariant. An amortized total-work claim alone also leaves old-version forks and prefix deadlines unpaid.

When $V_k=0$, every unfinished numeral has more than $k$ bits, hence its endpoint is at least $2^k$. Every endpoint below that cutoff is among the completed descriptors. This is valid negative evidence about the pending set. It is not yet a constant-cost test of all completed descriptors.

3. Why newest-first preemption is insufficient

The least-attained discipline matters. Merely replacing FIFO by a preemptive stack fails for a consumer that can expose only completed numerals and runs only its newest unfinished job. No additional pending-reader or threshold summary is allowed in this restricted example.

Fix the two ordinary names 0 and 1, and let $A$ bound all allowed observations of the older job between their releases, including record delimiters and any source-name routing. Release a small job with threshold $b=2^{A+1}$ under name 0. Before the next release it receives at most $A$ observations, so its $A+2$-bit numeral remains unfinished. At that delimiter release a new job under name 1 with a numeral longer than all subsequent service through a length-$b$ query, including its delimiters and source-name routing. The stack gives that newer job every remaining step. The small job never completes.

Replace the older endpoint by $2b$ in a second history. Its first $A$ least-significant bits agree with those of $b$; the newest job and every permitted completed observation agree. The query at $b$ must distinguish the histories but cannot. Arbitrarily large ordinary right inputs can prepare both legal rows at one common $H$; their actual size is charged and supplies no later service credit. This rejects this newest-only contract, not arbitrary preemption or metadata-rich readout. A fixed short-threshold mask escapes any fixed-cutoff instance, as in the existing FIFO analysis.

4. Native representations attempted

A persistent directory of age buckets. Moving a job from bucket $j$ to $j+1$ is easy with mutable bucket headers and a current finger. In a singly linked immutable directory rooted at age zero, replacing the header at depth $j$ and making the new state reachable from that root copies $j$ ancestors. Retaining a new finger separately leaves the old root’s header stale. Neither operation establishes constant local current-version access. This is a failure of that literal layout, not a lower bound on all directories. The current count-class analysis is a relevant warning; its lower-bound hypotheses have not been transferred to this scheduler.

Fresh low-age epochs above certified older groups. A new arrival could suspend the old frontier, retaining its attained-depth certificate, and start at age zero. Older groups need not be inspected on queries below their certificate. Once the new frontier reaches an old group’s depth, however, the groups must be combined without losing their priority order. A naive concatenation tree can accumulate an arbitrarily deep spine; paying only one root link per merge does not pay later pops. A bare FIFO does not offer constant-time concatenation. The Lab’s conditional catenable/shared-core controls retain their existing hypotheses; no new native deque premise is discharged here. Extracting a deque alone would also leave the completed-minimum operation unresolved.

Compare each newly completed endpoint with a saved minimum. A $k$-bit endpoint needs only $O(k)$ digit comparison work, even against a larger saved minimum. But doing that comparison synchronously can block later small releases. Deferring it creates a second queue, with stale candidate snapshots when earlier comparisons finish out of order. A comparison against an old candidate cannot simply overwrite a newer, smaller minimum. A paid version-coherent reduction or readable pending tournament is needed. The abstract screening bound does not provide one.

These are directly dependent failures, not reasons to restore the name/minimum gate silently. The next implementation should combine the epoch frontier and pending minimum reduction in a single invariant, counting every group link, skipped group, abandoned comparison, root handoff and query-prefix replay.

5. Evidence and next decisive test

The finite screening audit checks 11,480 release prefixes, 249,248 truncated-debt inequalities, 2,700 retained screening forks and 8,100 threshold membership comparisons. It handles a late endpoint 2 behind enormous numerals and 1,025 distinct equal-small completions. Eight explicit service/deadline witnesses illustrate the newest-only failure, a stale-commit witness checks the incorrect overwrite rule, and 509 integer phase inequalities check the displayed clock bound. Those witnesses use symbolic numeral lengths; they are not generated full ordinary right inputs.

The scheduler oracle scans Python tuples for minimum attained count. Integer bit length models exhaustion after the counted digit steps; the audit does not execute the native numeral codec. The semantic answer oracle scans the completed set. Neither scan, integer comparison, tuple copy nor retained set is asserted to be a bounded native operation. The checker is evidence for the conditional argument and its limitations, not a native implementation or an all-length proof.

Assessment-192 next test, continued in Sections 6-8: implement a persistent epoch frontier with certified lower bounds on suspended groups and a version-coherent pending minimum reduction, without a free minimum-age selector, uncharged bucket repair or free catenation. First charge a merge after many low-age interruptions and a late small completion during an older minimum comparison. Establish a joint bound on scheduler, reduction and reader-repair work before each query deadline, or exhibit a precise failing history. Preserve theorem 60 and the original late-small/equal-small tests.

The completed replay slices and affine joins have supplied bounded interfaces; this attempted frontier has an input-growing unresolved interface. Persistent causal and unary coherent constructions provide immutable dependency controls but no free ranked frontier. Native SAT constructions remain at their existing encodings and reversal contracts. The entry-129 quotient and matching/positive-path bounds remain separate from this uncompleted native implementation.

Source custody: one maintained note and checker. Claims: conditional scheduling bound and restricted failure only; theorem 60 and root ledger unchanged. Evidence: proof above and independent finite semantics. Failure ledger: newest-only starvation, literal bucket-root repair, unpaid epoch concatenation and stale minimum updates, with the reopen gates above. Frontier: joint paid epoch/minimum representation. Reader synthesis: this note and the program checkpoint. At that checkpoint, Site representation was deferred until a coherent native construction or decisive broader obstruction warranted publication. This note is now available as a generated styled reading, with highlighted source readings and exact downloads. No public homepage or publication-rank change follows from this unsuccessful native construction attempt.

6. Dyadic service can include the minimum reduction

Assessment 193, 10 October 2026. This continues the unsuccessful native construction attempt. The following written conditional argument removes the completed-set scan from the abstract worker. It does not implement the ranked frontier.

Let rank $j$ cover attained digit counts from $2^j-1$ through $2^{j+1}-1$. A newly released endpoint starts at rank zero. Its rank-$j$ screening block reads at most $2^j$ further digits. If its numeral continues, charge $\kappa(j+1)$ elementary repair steps before promotion, for a fixed positive constant $\kappa$. These stand for a possible traversal and reconstruction of a linked bucket directory. If the numeral ends in this block, its exact bit length lies in $[2^j,2^{j+1}-1]$. Its minimum-reduction task stays at rank $j$.

The proposed frontier contract is stronger than an ordinary FIFO:

1. Service a least-rank unfinished task. A smaller-rank arrival may interrupt any task, including repair and comparison, at an elementary-step boundary.
2. An active comparison has precedence over screening and new reduction tasks of its own rank. No same-rank comparison changes its saved minimum while it is suspended.
3. The frontier exposes the ordering of a completed endpoint’s rank and the saved minimum’s rank, and certifies when every task of rank at most a chosen cutoff has finished. Rank labels and these tests are granted interfaces here, not finite-control atoms in a native implementation.
4. Each retained version preserves its tasks, saved minimum and suspended comparisons. An arrival during a reconstruction is included in the successor version. No stale snapshot may replace the current frontier.

The numeric reducer now keeps just one completed minimum and its original reader roots. If a completed endpoint has smaller rank than that minimum, adopt it. If its rank is larger, discard it. For equal ranks, compare the two canonical numerals by successive least-significant digits, retaining the order of the most recent unequal pair until both numerals end. This uses at most $2^{j+1}-1$ digit steps at rank $j$, plus bounded setup. It does not use integer comparison of endpoints or scan all completed values.

The preemption rule is sufficient for version coherence. A same-rank arrival cannot change the minimum before the active comparison commits. A strictly smaller-rank completion is smaller than both operands of a suspended higher-rank comparison, so that comparison may be discarded. Smaller-rank screening that produces no smaller-rank completion does not change the saved minimum. Thus a resumed comparison either still has its original minimum or is irrelevant. It never overwrites a newer smaller answer. This is a joint scheduling/reduction invariant, not an address-identity test. Cancellation and rank access still belong to the frontier contract.

6.1 Linear truncated work, including comparisons and directory repair

Fix a rank cutoff $J$ and write $K_J=2^{J+1}-1$. Each job needs at most $K_J$ screening digits through that cutoff, at most one completed comparison of at most $K_J$ digits, and at most

$$\kappa\sum_{j=0}^{J}(j+1) =\kappa\frac{(J+1)(J+2)}2$$

repair steps. Allowing three extra setup/cancellation steps, a uniform per-job envelope is

$$C_J=2K_J+\kappa\frac{(J+1)(J+2)}2+3.$$

Since $(J+1)(J+2)/2\le2^{J+1}$, one fixed constant $A$ gives $C_J\le A2^{J+1}$. For the finite audit’s normalized $\kappa=3$, $A=12$ is more than sufficient. A concrete implementation would have to choose its own constant for all primitive observations, frames and allocation. Geometric promotion therefore permits an $O(j)$ repair at rank $j$ without an $O(k\log k)$ cost through digit depth $k$. It does not make that repair atomic.

Assign a newly released job $C_J$ credits for work through rank $J$. Each elementary service step at rank at most $J$ consumes one. Finishing or discarding the job, or promoting it above $J$, removes unused credits. The envelope pays its entire possible screening, repair and reduction; interruptions do not restart comparisons. While any such credits remain, least-rank service performs a charged step for one of those jobs. Higher-rank work cannot consume that service. The last-busy-period argument from Section 2 therefore applies to the credit total, including reduction work:

$$W_J\le B_q(C_J)=C_J+\sum_{d\ge1}2^d(C_J-qd)_+.$$

This holds after every distinct-name release when $qd$ primitive steps are supplied during the next ordinary name of length $d$, before its endpoint is released. Duplicate names add no task. The proof needs neither a bound on selected population nor the theorem-60 name/minimum inequality. It does need the interruptible priority contract; counting credits does not construct that contract.

When all ranks through $J$ have drained, every unresolved endpoint has more than $K_J$ bits. If the saved minimum has rank at most $J$, it is the exact selected minimum. Otherwise all selected endpoints are at least $2^{K_J}$. This includes completed and unfinished jobs without a completed-set scan.

6.2 Conditional query schedule and reader repair

The joint contract suffices for the missing deadline argument. For a query stage $k\ge4$, choose the least $J$ with $K_J\ge k$. Then $2^{J+1}<2(k+1)\le3k$, so $C_J\le3Ak$. Choose the fixed name-service rate $q=64A$. The preceding bound implies

$$W_J\le3Ak+256A\,2^{3k/64}.$$

At stage time $T_k=2^{k-4}$, division by $T_k$ bounds the first term by $12A$ and the second by $512A$: for $k\ge4$, $61k/64\ge3$. Hence $1024A$ primitive steps per target symbol finish the stage before $2T_k$, including at its birth symbol. Stage four finishes in its first batch. The rank and stage counters, selector, cancellation and coverage flags would all have to be realized within the fixed implementation constant, with no integer-rank oracle.

An empty stage certifies every endpoint at least $2^k$. A later stage that discovers the minimum finishes before $2^{k-3}$, while the preceding certificate puts that minimum at least $2^{k-1}$. The inherited four-step lag repair aligns its original unary lower reader before that minimum can affect an answer. At the first stage, repair of the one-symbol lag occurs in the birth batch, covering endpoints as small as one. The common upper reader remains independent. Thus the assumed joint frontier supports exact answers at every final symbol, not merely eventual completion of the minimum.

This is a conditional transfer for the existing right-first, common-maximum suffix task. Right-row preparation, ordinary-name routing, duplicate detection and the upper ruler retain their existing charged contracts. No supplied handle, padding, extra EOF work or independent-store join is introduced. A native realization would still use one fixed machine, finite labels/control, bounded degree/radius and chronological old-top updates; its PEG consequence would still concern reversal. None of those realization obligations is discharged by the abstract worker.

7. The concrete repair attempt still fails at interruption

The logarithmic directory route was tested with the joint reducer instead of a completed-set oracle. It removes one numerical work objection but exposes the version boundary precisely.

Finishing a deep repair before accepting new work fails. In the literal unary linked directory, promotion at rank $j$ traverses and copies a path of length proportional to $j$. An old huge endpoint can reach an arbitrarily high rank during arbitrarily much legitimate intervening input, including repeated selections. Release a small endpoint while that promotion has more repair steps remaining than the fixed service available through its short query. If repair is nonpreemptible and the small endpoint is visible only after it completes, the answer is late. The old endpoint’s size and the earlier input are fully charged; neither supplies extra steps after the new release. This is a failure of that nonpreemptible layout, not a native-language lower bound.

Preempting and then installing the saved replacement root loses arrivals. A promotion starts from an immutable directory snapshot. A new small endpoint is inserted at rank zero in a newer version. Installing the completed replacement of the old snapshot discards that insertion. Retaining both roots avoids loss, but leaves a join to perform. Replaying the arrival log or walking an unrebalanced concatenation spine is not constant local work merely because each interruption allocated one node. The example in the audit loses an explicit new-small item under stale replacement; a thousand constant-size concatenations give a thousand-edge path to the oldest item.

The same issue appears if a completed minimum is attached only to the discarded frontier version. The rank-safe reducer in Section 6 avoids numerical stale-result commits, but it presumes that the current version still reaches every task and the current minimum. It does not repair a lost current root. A correct overlay must therefore preserve both task coverage and minimum ownership across suspension and adoption.

Reopening this route requires a step-level overlay or epoch representation that keeps arrivals immediately reachable, resumes old repair without replacing a newer root, and bounds future join traversal. A catenable queue, ready rank comparison, mutable bucket header or memoized future cannot be silently added. Their construction, old-version behavior and access would have to be paid in the same truncated-work bound.

8. Current evidence and next target

The dyadic frontier audit executes counted numeral comparisons and promotion-repair steps in immutable states. It tests retained versions, lower-rank cancellation, same-rank waiting, long-then-small arrivals and many equal-small selections. Its independent answer oracle takes the direct minimum only outside the worker. Unlike the earlier screening checker, the worker has no completed-set answer scan.

Python integer ranks, tuple selection/copying, class ordering and coverage queries remain explicit frontier oracles. Bit length models numeral exhaustion. Synthetic deep-repair and stale-root examples diagnose the literal layouts; they are not full encoded native executions. Finite experiments corroborate the written conditional argument and do not establish its native antecedent.

Intermediate next test, resolved for suffix minima in Section 9: implement an interruption-safe persistent rank frontier for the joint screening/reduction worker. Start with one deep promotion, insert a small endpoint during every repair phase, and then nest many such interruptions. Prove that each successor version reaches both its arrivals and its saved minimum, without replaying the whole arrival log or walking a long concatenation spine. Charge rank ordering, cancellation, coverage certification and reader repair together. The geometric work envelope is available; the current-root adoption mechanism remains the bottleneck.

At this intermediate checkpoint the native theorem count and theorem 60 remained unchanged. This is a conditional joint readout and a sustained failed directory implementation, not a new native recognizer or novelty claim. Source custody, proof and experiment, failed-layout reopen gates, current frontier and reader synthesis are retained here and in the assessment review. Site publication remains deferred until the frontier is realized or a broader decisive boundary is established. The original replay, affine, causal, unary coherent and SAT controls keep their own bounded interfaces; none supplies this growing current-version frontier. General intervals, varying maxima and independent-store composition remain separate.

9. Resolution of the suffix frontier

The same assessment replaced the deep directory with a sparse list updated only at its first two buckets. Unary gaps remove rank comparison, and upper-tail deletion makes the completed minimum locally observable. See written native theorem 61 and its explicit immutable checker. The generic directory failures above remain valid; the common-maximum suffix specialization is now closed. The current target is heterogeneous upper endpoints, where tail deletion may lose necessary coverage.