Short answers, late receipts and current-version routing

Assessment 244, 13 October 2026. A sustained failed extension, with a positive service control and a restricted insertion obstruction. Construction 85 remains the latest native result.

What the attempted extension reveals

A long owner name can select a very short target name. It is tempting to conclude that the long activation has enough time to prepare the short answer. But a learned right table may reveal that target only when the owner name ends. Time before that release does not pay a newly started insertion. The remaining problem is to put that late receipt into a representation that both preserves earlier receipts and lets a short query find its current answer.

Consider three activations whose target lengths decrease sharply. The first long owner supplies ample time before its target is known. The second owner is long compared with its own target, yet too short to finish inserting the first target. The third can be too short to finish either earlier target. Every edge is a contraction, but an explicit installer can still accumulate unfinished work. Section 3 makes this example arbitrarily large without adding any input padding or preprocessing phase.

This investigation tests the extension from construction 85 to much shorter ordinary queries. The strongest surviving positive statement is an adaptation of the existing pending-overlay method: a bounded batch of late receipts is enough when each next same-source record pays to install the previous batch. Removing that successive-service condition remains open. Servicing all shorter length classes does not by itself supply the final operation that routes a newly selected receipt into its current class.

1. Exact language and the proposed representation

Use section 15’s ordinary right-first Horn language: right records define S from intermediate names v to targets w, left records define R from sources u to v, and late ordinary pins select a source a and target b. Binary names are nonempty. The actual length is

$$N=\sum_{(v,w)\text{ right records}}(9+|v|+|w|) +\sum_{(u,v)\text{ left records}}(10+|u|+|v|)+11+|a|+|b|.$$

Duplicates count as actual records. Fix a right-row bound d. The frozen dictionary D(v) contains at most d distinct target FIFO receipts, constructed and duplicate-checked during the actual right block. Missing rows are empty. No route, decomposition or extra time field is supplied. The present contraction test additionally requires $|w|\le |v|$; it is checked by comparing a saved owner-length ruler with the actual target, stopping and rejecting on excess. This gate does not restrict source-name lengths.

For each source, try one committed target trie T and one pending tuple P of at most d target FIFOs. The invariant would be

$$T\cup\operatorname{words}(P)=\{w:\exists v\ ((u,v)\in R\land(v,w)\in S)\}.$$

The source’s actual name retrieves the current descriptor. During the following v, an installer drains old P into T while frozen D is looked up. At the end of v, D(v) becomes the new pending tuple. Queries traverse T while comparing the same arriving target bits against the at-most-d pending FIFOs. A mismatch stops that comparison immediately; exact exhaustion distinguishes equality from a proper prefix. Thus a short query need not read an entire long pending word merely to reject it.

Everything in this representation is paid and versioned. In particular a receipt is a pointer to an immutable spelling, not a free current membership bit. The attempted unrestricted step is replacing P when its old batch has not finished.

2. A positive control: service-admissible sequences

Fix the installer and a fixed number C of normalized installer jobs per actual owner bit. A normalized job expands into a bounded batch of FIFO, capsule, label-observation and allocation operations; C does not vary with the input. Begin draining P when v starts. At the delimiter, require that the entire old batch has finished before replacing it. Reject inputs that fail this explicit scheduling gate. Delimiter setup, terminal marking and fixed-arity receipt replacement have their own bounded sub-batch.

This defines a checked sufficient subclass. Its condition depends only on the input and fixed deterministic scheduler, not on guessed advice. A simpler sufficient bound is

$$A\sum_{w\in P}(|w|+1)+A_0\le C|v|,$$

where A and A_0 bound this fixed installer’s complete batch work. The machine need not perform multiplication or compute the sum at the delimiter: successful completion of the scheduled job is the local guard. This bound is sufficient, not an exact characterization of every implementation’s work.

The invariant follows by induction. Draining adds exactly the pending words and changes no logical membership. A successful replacement adds exactly D(v). Missing rows, duplicates and empty initial pending tuples cause no problem. After each committed left record, querying the committed flag OR exact pending comparisons returns product membership. Its complement, computed by the final ordinary punctuation, is the pinned SAT answer. There is no final flush.

For example, if all owner names have one arbitrary common length L and targets have length at most L, a fixed C depending on d,A,A_0 suffices. More generally it suffices that owner lengths do not decrease along each source’s successive left records, while every target is no longer than its owner. Different sources may interleave arbitrarily. These examples permit arbitrarily deep contractions, unbounded image and arbitrary data-defined substitutions. No spelling transducer or target-class routing is needed. More irregular sequences can pass the operational service gate as well.

This is a direct reuse of section 15’s paid receipts and global pending overlay, not a new structural characterization or a new numbered native construction. Its native implementation uses fixed labels/control, fixed degree/radius, fixed initialization and old-top observation through the established simultaneous-record compiler. The number of active FIFO and trie workers is fixed by d,C. Every preparation, discarded or successful installer job, query comparison and allocation is charged to the actual N. Logical work/storage is O(N), serialized pointers cost O(N log(N+2)) bits, and the inherited compiler produces N+1 physical nodes after initialization. The PEG consequence is only reversal of the complete checked language, including its scheduling gate.

The source input remains the ordinary section-15 syntax; the gate is a restriction on which such formulas are accepted, not a claim to recognize all contracting tables and all left orders. Retained completed descriptors answer historical queries correctly. Starting the next update from a stale descriptor is not permitted.

3. Arbitrarily strong contractions still overflow a fixed global overlay

Here is a restricted failure that the earlier expansion witness does not give. Fix an overlay capacity $B\ge1$, a total post-release installer rate $C\ge1$ per actual symbol, a fixed allowance $H\ge0$ covering the remaining punctuation of the releasing record and any extra final-boundary work, and a desired contraction factor $Q\ge2$. Consider an explicit installer with these rules:

• A selected target’s insertion is first available at its selecting owner endpoint. No speculative insertion for that receipt is credited before release.
• Completing a length-L target requires at least L charged jobs after release, even if the trie already has other words. The procedure performs literal word insertion, without prefix-skipping or a shared aggregate shortcut.
• At a completed left-record boundary, each selected target is either fully installed or retained as one of at most B exact-word receipts. Jobs may be scheduled in any order or preempted.

These are implementation assumptions, not properties of all native representations. Let $k>B$ be arbitrary and use one source name of length one, so a later left record with owner length V has exactly V+11 symbols. Define lengths backwards by

$$L_i=C\sum_{j=i+1}^{k}(V_j+11)+H+1,\qquad V_i=Q L_i.$$

The sum is empty at i=k. Choose H large enough to include the fixed number of symbols after an owner endpoint in its own record, as well as any allowed final fixed batch; these costs cannot grow with name length. Choose distinct binary owners of lengths V_i and distinct targets of lengths L_i, and one right edge for each pair. For instance, names ending in 1 with all preceding bits 0 suffice; their different lengths distinguish them. Every right row is functional and every edge has |v_i|/|w_i|=Q. The right block literally contains these names, and the left block selects their owners in the displayed order. The family uses no extra padding field; each symbol belongs to an actual ordinary name or delimiter.

Even granting the whole later left input and the final allowance to a single receipt, receipt i receives at most

$$C\sum_{j=i+1}^{k}(V_j+11)+H=L_i-1$$

post-release jobs by the final boundary. Thus none of the k insertions can finish. All k distinct targets still require receipts, contradicting capacity B. Giving every receipt the full later budget is generous; competition between jobs can only reduce its available service. For i=k the final allowance alone is insufficient. This proves failure for every fixed B,C,H, even for any chosen contraction factor Q, with genuinely unbounded selected image even while B,C,H,Q are fixed. The minimal witness takes k=B+1.

The final query is not used to rescue a representation already required to be complete at each left boundary. If a proposed interface instead permits unfinished unbounded state until the pins, it leaves this contract and must provide its own paid short-query reader. Likewise literal target names with simple patterns could be compressed by a different representation. The argument excludes that compression explicitly rather than treating name length as information complexity.

Unlike section 15.7’s short-owner/long-target witness, this failure uses only long-owner/short-target edges. It shows why the budget comparison must respect release times and successive operations, not merely compare the two ends of each edge. It is not a lower bound on native SAT or persistent recognition.

4. Why a sweep over all shorter classes is not yet a repair

In the class directory, bucket j holds at most d words shorter than 2^(j+1). Draining all buckets through J therefore has a linear total bill in the largest length:

$$\sum_{j=0}^{J}Ad(2^{j+1}+1)=Ad(2^{J+2}-2+J+1)=O_d(2^J).$$

The existing geometric clock can schedule that service while an owner of class J arrives. But the target class is not generally known until D(v) is selected at the owner endpoint. Having drained a bucket earlier is different from retaining its current update cursor within fixed-radius access. A fixed current window contains only constantly many nearby buckets. An earlier bucket can be arbitrarily far away in the directory prefix, even though it is empty and ready for a new receipt.

Section 15.7 already identified this access gap. The present attempt tested whether the stronger all-shorter service budget removes it. It does not: the sum proves sufficient service, while the delimiter still needs a destination-selection operation. We have no bounded local implementation of that operation for arbitrary learned target classes. A growing collection of saved cursors is not a fixed control tuple, and a class number is not an address.

A concrete family separates the two bills. Let J be an even integer, $M=2^J$ and $k=\lceil\log_2 J\rceil$. Use J/2 distinct owner names P t_r of length M, with one common prefix P of length M-k and distinct k-bit tails. Map owner r to a target of length 2^r, for $0\le r<J/2$. All rows are functional and all edges are strict contractions; the image grows with J. The target spellings and association are arbitrary actual right-table data.

At the start of the distinguishing tail, the existing length-driven current window is at class J-1. Any selected target bucket is at distance at least J/2 from that position. Even granting its destination at the beginning of the tail, a single serial directory cursor cannot traverse that distance in k+O(1) remaining symbols at any fixed speed for all J. Before the last owner bit, the current length class is J-1; it becomes J only at that bit. This off-by-one does not affect the growing gap. This witness concerns the stated current-window route. Earlier retained alternative cursors, threaded current indexes, different directory topology or speculative routing can escape it and must be separately charged.

Four repairs were examined:

1. A prepared bucket handle. Right preparation precedes future per-source activations. A handle into the frozen template is not the current source’s bucket version. Source/version lookup or a maintained indirection layer must still be paid. Immutable old nodes cannot acquire forward edges to newly allocated versions.
2. One global late tuple outside the directory. This avoids the immediate class lookup and gives the positive control in section 2. The descending-contraction family defeats every fixed capacity under the stated literal-installation and release rules.
3. A deferred association list. It can retain arbitrarily many class/receipt pairs, but the query proof no longer has only a fixed number of candidates. A secondary current index, a paid traversal or a separately proved aggregate is needed. This is an unpaid operation, not a lower bound for every possible list algorithm.
4. Retain pending words by owner class. This makes update placement timely, as in construction 85. A much shorter target does not determine its owner’s class in an arbitrary learned table. Querying all owner classes is not covered by the fixed current/ahead reader. The long-owner pointer at the end of a short lookup does not itself pay the traversal.

No one of these diagnoses rules out an input-built shortcut, a different factorization, early speculative preparation or a versioned aggregate. They explain exactly which additional operation would escape the tested contracts.

5. Controls, evidence and next decisive test

The independent checker tests symbolic descending witnesses and finite committed-plus-pending invariants, including retained snapshots. Its integer budgets do not implement a native graph machine or prove the infinite statements. The review records the actual scope and checks.

Construction 85 still admits unbounded length classes when ordinary query fields identify and pay their owner’s scale. Constructions 81-84 maintain structured shared shorter coordinates; they escape literal long-owner readout under their stated preparation and map restrictions. Replay charges every fork, affine joins require their coordinate contracts, causal persistence preserves history without creating a new current-version lookup, and unary coherent consumers do not supply arbitrary branching joins. Entry 129’s imported matching/positive-path theorems retain their own interfaces, growing alphabets and state/port conclusions. No semantic quotient is promoted to a native lower bound.

The next decisive target is a paid current-version selector for late contraction receipts. Test a source-shared directory in which ordinary preparation and activation jointly make the selected shorter bucket accessible by the owner delimiter, without a supplied route, a stale handle, an unbounded fixed-control tuple or a final traversal. Alternatively, construct a shared aggregate that bypasses bucket insertion and prove short-query access. Compare any proposal against both the service-admissible positive control and the descending-contraction failure. Arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service remain open. The next primary review and editorial pass preserve this target.

This is a completed failed extension with a sharper test, not another native theorem. Root claims, construction count and mathematical reassessment count remain unchanged.