Cross-scale reuse: terminal masks, union compilation and release time

Assessment169, 9 October2026. Supporting representation construction and a sustained unsuccessful attempt to remove theorem46’s name-span gate. No new native language endpoint, root admission or novelty claim.

1. Strongest exact conclusion

Bounded coefficient-prefix breadth does not bound the complexity of the terminal masks along the reader. Even breadth zero contains arbitrary finite sets of accepted word lengths. Their composition is ordinary set union. Nevertheless, a completed finite row family has an acyclic, immutable compiled union interface: an ordinary row name performs a transition while it is read, and an ordinary target word reads the resulting answer while it is read. The compiler below charges its exponential preparation explicitly. On a dense family witnessing failure of eager merging, that preparation fits the actual right-input budget. Thus the remaining issue cannot be inferred from total work or from the eager merge backlog alone. It is timely construction of the current interface from still-arriving rows.

The checkpoint owns continuation. Theorem46 remains the native endpoint. The representation here is a prepared interface, not a supplied-handle assumption smuggled into that theorem.

2. A zero-coefficient test family

This is the radial-row control already recognized under span in reader35, used here to isolate what remains after coefficient preparation is removed. Its semantic description is not counted as a new discovery.

Choose distinct nonempty ordinary binary row names v_1,…,v_m and finite sets D_i of positive integers. The right row is

S_i = union over n in D_i of {0,1}^n.

Present it by all its ordinary right Horn records, in any order. At a fixed width its characteristic function is constant zero or constant one. Every nonzero-frequency Walsh coefficient is zero. Hence per-slice Fourier rank, final future rank and nonzero-coefficient prefix breadth are all zero. The constant Walsh coefficient remains in the terminal mask, not in that trie.

For a source selecting rows indexed by A, the product contains a target b iff

|b| belongs to union_{i in A} D_i.

This follows directly from the existential intermediate vertex. Terminal pins give SAT exactly when this condition fails. Every subset of {1,…,H} is realized as a terminal profile by choosing a single D_i. Distinct profiles are distinguished by a word of a differing length. This is an exact semantic embedding, not a lower bound obtained from the number of profiles.

The full literal input cost is retained. For these right rows it is

N_right = sum_i sum_{n in D_i} 2^n (9 + |v_i| + n).

In particular, this is not a polynomial-size reduction from succinct Boolean union. The dense encoding may finance very large preparation.

3. What fails when only the service window is moved

Theorem46 uses the two span directions separately. The bound |v|=O(n) controls a producer job’s saved-key routing and publication. The bound n=O(|v|) lets the next key pay that job and, independently, lets a left reuse name pay the pending row’s conversion and mask-profile union. Its finite small-width branch also uses a bound on key length. Removing either inequality therefore invalidates more than one line of the schedule.

For expansion-only records, |v|<=C n, one can propose servicing old jobs during the next target spelling. The old target in a dyadic class has comparable length, and its saved key is short enough. This gives a numerical O(n) service budget. It does not yet give a producer: row selection, current-root refresh, replay of the already consumed target prefix, wrong-class rollback and serialization of global coefficient edits need one compatible schedule. More importantly, even a completed producer would not fund the later left merge, whose target word is absent from that left record.

Here is a precise failure of the inherited eager-profile protocol. Represent a source’s terminal masks by an immutable unary list, with one cell per depth. Require merging a pending row to publish the resulting unary list by ordinary path copying. Allow at most K directly readable pending rows, no precompiled union table, no chunked profile and no alternative aggregate representation. Selecting a singleton profile at depth n whose bit was zero changes that cell and every predecessor pointer. It allocates at least n fresh cells. The proof is backward induction: the changed terminal cell differs, and each preceding cell must now point to the changed suffix. A suffix after n may be shared.

Take m distinct equal-length keys of length ell=ceil(log2 m), using at least one bit, and D_i={H+i}, 0<=i<m. All selected depths lie in one class when H is a power of two and m<=H. After selecting all m rows for one fixed short source, let T be the actual local operations spent in the left block. Then

pending >= m - floor(T/H).

Indeed every discharged distinct pending singleton requires at least H allocations under this protocol. A fixed symbol budget gives T<=q m(ell+c), including source names and punctuation. Choosing H much larger than q(ell+c) and m>K violates the fixed-pending contract. This already happens with zero coefficients and no coordinate conversion at all. Duplicate selections and previously set bits are excluded in this witness.

The statement assumes the left block starts without a precomputed transition table and disallows batching into another representation. It rules out the literal extension of the existing eager-profile scheduler only. It does not rule out the next construction, a balanced mask index, lazy aggregation, prepared alternatives, or a native recognizer.

4. A fully charged prepared escape

Let the completed row family have m distinct names, total name length L, and all D_i contained in {1,…,H}. Empty rows and missing names are allowed. Compile one state root R_A for each subset A of {1,…,m}. It contains:

• a unary answer profile for union_{i in A} D_i;
• a binary trie over the ordinary names v_i. Its terminal action is KEEP if i is already in A, and otherwise a pointer to R_(A union {i}). An absent name also acts as KEEP.

Build subsets in decreasing binary order. Adding a missing member strictly increases that order, so every target state already exists when its transition is allocated. Build each name trie bottom up, then its state root. KEEP is a finite label interpreted using the current state root, not an edge returning to that root. Thus all actual edges point to older records. There is no cycle hidden in a long trie path, no pointer-identity comparison and no mutable mark. Finite labels and a fixed maximum outdegree suffice. Nonuniform numeric addresses are not observations available to the interface.

A row update starts from its current state root and follows the ordinary bits of v. At the delimiter the terminal action supplies the new root or KEEP in bounded additional work. Prefix names are separate terminal flags, so they cause no ambiguity. A target query walks the unary answer profile once per actual target bit, ignoring the bit’s value; exhaustion gives false. The answer at its delimiter is exact. Every old root remains a valid snapshot. The online costs are O(|v|+1) and O(|b|+1), with fixed work per symbol and bounded delimiter work, independently of H/|v|. Repeating a selected row is idempotent. No final normalization or scan of selected rows occurs.

Preparation is not free. Retain m-bit subset words in a binary dictionary. For each state, build its profile by scanning the m input profiles, costing O(mH); for each missing member, construct and look up the destination subset word, costing O(m), hence O(m^2) per state. Name-trie construction costs O(L+m), using explicit finite-field stacks and bit comparisons. Retained temporary data and dictionary path copies are also charged. A conservative uniform bound on both work and retained logical allocations is

P = O(2^m (mH + m^2 + L + 1)).

Extraction from prepared row profiles and all compiler dictionaries belong to P. If starting from dense literals, reading and checking those literals is an additional cost, not hidden inside P. For the radial control it can be done offline in O(N_right) work: ordinary tries detect distinct words, unary depth profiles select counters, and O(n) binary-counter/capacity work per width-n record checks complete levels. This is a whole-record offline bound, not a strict per-symbol producer. The supplied finite row family is an input to this prepared compiler, not advice: no claim is made that the compiler has finished by the last literal right symbol. The construction is an explicit finite-degree chronological DAG, not an ordinary RAM table whose address bits are read for free. The online reader uses only labeled edges and finite control. A uniform machine can enumerate subset words with explicit stacks; its constants do not depend on m or H.

For the backlog family with m=2^ell, H_0=m^2, and depths H_0,…,H_0+m-1, use H=H_0+m-1 in P. Then P=O(2^m m^3), whereas N_right>=H_0 2^(H_0). Consequently P=O(N_right). This same family has unbounded H_0/ell and defeats the eager protocol for every fixed q,K, yet it does not have an insufficient total-input budget for this compiled escape. The estimate counts real dense literals, not inserted padding.

This is a prepared one-row-at-a-time union interface, not a constant-time join of independently prepared roots. It also does not contradict entry129: the compiled interface has exponentially many subset states, and no matching or positive-path extraction with small ports has been supplied.

4.1 The same compiler supports the completed bounded-breadth reader

The escape is not specific to radial rows. Suppose a completed family has maximum target width H and final coefficient-prefix breadth at most fixed B. Apply45’s paid O_B(H) conversion to each of its m row readers. At every depth, the common reader has at most B terminal coefficient tests; a row’s answer is a finite Boolean mask on those tests. Nonterminal active prefixes are carried by the same bounded frontier, and absent widths have the zero mask. All these conversions cost O_B(mH) and are included in preparation.

For each subset A, form a depth profile by bitwise OR of the converted row masks at each depth. Keep one immutable common coefficient reader shared by all states. The state transitions are exactly the same name tries as above. During a target query, advance that common reader and the chosen state’s mask profile together; at the target delimiter evaluate the finite mask on the exposed terminal parities. Constants depend on B, not the number of rows, widths or name-length ratio. Profile construction costs O_B(mH) per state, so the same bound P holds with a B-dependent constant. If there are no widths, the single empty-answer representation handles the degenerate case.

This supplies a span-free prepared composition/readout interface for the whole completed breadth class. It charges conversion, all alternatives and routing; it still does not construct that interface by the original right-block deadline. It is a written finite-state compilation adaptation, not a claimed new subset-construction principle. Its chronological realization and strict ordinary-name access are the relevant resource details here.

5. Why the prepared construction is not the missing native theorem

The compiler above is released after the row family is known. A literal right block reveals neither its last row nor the final collection of width masks in advance. Its total earlier length cannot automatically be spent after that release point. A naive incremental repair doubles the subset universe when a new independent row appears, and a naive change of one D_i affects all states containing i. Neither loop can be performed at a delimiter.

Nor can a new transition trie simply reuse old state roots as its destinations while promising that those destinations understand all new actions. For example, the old family has row a of width1. Add row b of width2. A new empty state whose a action returns the old a-state loses b if the old a-state treats the previously absent name b as KEEP. The sequence a,b then answers false at width2. Appending the new input’s row data does not mutate that old root. Version-specific states, delayed overlays or a separately justified coupled reader are needed. This is the same current-version issue isolated in the earlier cross-scale routing investigation, now exposed even without coefficient interpretation or target-name decoding.

Prebuilding every alternative, partitioning the depth axis into paid blocks, or retaining version-coherent action overlays remain possible. None is ruled out by the backlog inequality. No efficient online compiler for them is proved here. Bounded left fanout already supports finitely many direct readers; fixed finite terminal image supports finite masks; neither resolves unbounded terminal-profile union. Replay slices pay a known released traversal but do not create its start time. Affine/shared-coordinate readers preserve local meaning but do not collapse arbitrary width masks. Persistent causal and unary coherent constructions preserve old versions rather than updating the meaning of pointers to them. These controls all agree with the separation.

5.1 A restartable compiler gives a concrete sufficient deadline contract

There is a useful alternative to repairing every historical compiled state. Right-block snapshots are preparation states, not yet left-query states. Whenever a producer publishes a changed completed row family, discard the current compiler continuation and start a new one from that immutable snapshot. Keep a ready flag false until the new compiler finishes. A later publication invalidates that flag and restarts again. The compiler enumerates all states afresh, so every destination belongs to its one frozen action family. Earlier snapshots remain unchanged and need not understand new rows.

Assume a producer supplies such snapshot roots by bounded local publications, including all row names, profiles and the common reader; has immediate exact validation of every literal; and publishes its final semantic snapshot at least Delta actual symbols before the right boundary. Assume the uniform explicit-stack compiler takes at most P steps on that final snapshot. With a fixed q compiler steps per subsequent actual symbol, P<=q Delta guarantees readiness by the boundary. All abandoned work is charged to those symbols, so the whole history still uses O(N) work and allocations. Snapshot capture and restart are fixed-tuple operations, not scans. Completion refers to the current continuation: every publication resets it, so no pointer-generation comparison or stale completion can set the ready flag. Zero uncertified slices and ready are both required at the boundary. Immediate validation can continue after the last semantic publication without restarting an unchanged compiler.

This is a conditional scheduling consequence, not the missing producer. It also gives a nonvacuous quantitative target. Let all occupied widths lie in [n,c n], let m<=alpha n for fixed alpha<1, and let L be polynomially bounded in n. Then the compiler cost is 2^(alpha n) times a polynomial in n. A final publication with the dense learner’s Omega(n 2^n) remaining-symbol margin would pay it for all sufficiently large n; a fixed service multiplier covers the finitely many smaller admitted cases. Short row names are permitted, so this can cross the expansion-side span boundary. These parameter inequalities are sufficient size conditions, not a claimed checked native language.

What must still be proved is an ordinary-input producer with the stated snapshot release margin after span removal, including all row/width dispatch, publication routing and gate validation. Theorem46 supplies a release margin under its own span hypothesis, which must not be silently reused outside that hypothesis. This restart contract avoids the stale-state counterexample and identifies a positive avenue for the next push, alongside incremental action overlays. It is not necessary to solve arbitrary online confluent union before testing this narrower producer-plus-final-slack route.

5.2 Concrete producer candidate for the restart contract

The next construction test can be much narrower than arbitrary span removal. Let n_0 be the first actual target’s length. For fixed C, require all targets to have lengths in [n_0,2n_0], all intermediate keys to have length at most C n_0, and at most floor(n_0/4) distinct nonempty right rows. Retain final per-slice rank and coefficient-breadth gates. These are proposed input checks, not supplied widths or row decompositions. They allow arbitrarily short keys relative to targets, so they genuinely cross the expansion-side span boundary.

Here one global pending producer job could replace the dyadic class window. Its saved key, target, path closures and learner credit all have O(n_0) size. During the next target, first finish that old job, then replay the retained current key against the refreshed row dictionary, and finally catch up on the current target prefix. A fixed larger rate would put these three stages in successive fractions of the first n_0 bits. The entire current key must be retained because the initial lookup may precede the old job’s dictionary update. Immediate literal membership and width-count updates must still be exposed by the target delimiter. The first record has no old job and must bootstrap its rulers and singleton capsule from its actual bits; a separate finite small-width branch is possible under the key/population bounds.

The table budget is then O_(r,B,C)(2^(n_0/4) poly(n_0)), while a successfully published final dense slice potentially leaves Omega_r(n_0 2^n_0) symbols. This closes the numerical gap. The unresolved proof obligation is the complete simultaneous old-top implementation of the three-stage target catch-up, including bootstrap, discarded invalid inputs, current roots, exact width selection, counter updates and a final raw capsule that hides no validation. Only after that producer and the final-publication margin are proved may5.1 be invoked to claim a new native endpoint. The present finite checker does not execute that producer. This concrete candidate should be tested before attempting an unrestricted incremental action compiler.

6. Next decisive test and evidence disposition

The next review should compare at least two full primary mechanisms for worst-case functional/confluent union and incremental compilation with readable incomplete results. Test the zero-coefficient width-set family first. Compare restartable snapshot compilation as well as incremental action repair. The target is a version-coherent action interface constructed during actual dense right records, usable by ordinary short left names, and readable during the actual late target pin. Account for release time, each new row’s action availability, old-root semantics, total retained history and final-symbol deadline. A proof of O(N) total preparation alone will not close it.

The independent finite checker reconstructs full-cube rows, verifies their Walsh supports, compares union answers to direct existential Horn paths, builds chronological compiled state graphs and reads them only by labeled edges, checks retained snapshots and missing names, and exhibits the stale-version failure. Arithmetic tests separately check the eager backlog and dense-input budget. Finite checks corroborate the written construction; they do not implement a strict online producer or prove a native lower bound.

Custody: original argument and checker only. Claims: supporting semantic restriction, prepared interface and restricted failure, no new root claim. Failure ledger: retain both eager backlog and stale destinations with their explicit escapes. Frontier: online current-version compilation, plus separate exact-rank gate and independent-store joins. Reader synthesis: theorem46 stays current. Site: no new public theorem section or homepage promotion for this unsuccessful span-removal attempt; the research handoff is maintained in source.

6. Comparable-width native successor

Assessment170 closes the comparable-width producer, refreshed lookup, buffered target catch-up, final release margin and suspended source-payload closure. The maintained complete proof is now reader47. It uses this note’s prepared compiler, so that construction has one maintained source. For fixed r,B,C, first target length n0, target lengths [n0,2n0], keys at most C*n0 and at most floor(n0/4) right rows, the actual dense suffix pays all compilation before reuse. The lower key-length bound is absent. This is a written native subclass construction; the arbitrary-width/population case and independent-store joins remain open. Sections1-5 record assessment169’s earlier prepared result and then-open transfer, not the current endpoint.

Review170 compares two full primary papers, records the finite evidence and identifies the next structural test: semantic union complexity in place of the raw row count. No new root admission or novelty claim follows from this native extension.

7. Semantic union successor

Assessment171 replaces subset enumeration by exact semantic union discovery. Reader48 owns the normalized-mask compiler, its preparation bound, checked population/union gates and complete native transfer. This note retains the older compiler used by47. Small J alone still does not pay a late rebuild of an unrestricted ordinary-name inventory; reader48.6 gives the precise full-restart failure and incremental alias escape.