Cross-scale composition: short routes are not ready routes

Assessment127, 7 October2026. Contract investigation and sustained unsuccessful native-construction attempt. The arbitrary cross-scale functional-right problem remains open. This note gives an elementary offline routing construction, an abstract code-ready representation, four rejected implementations and a precise next contract. It does not add a native theorem, root admission, novelty claim or formal verification. The program checkpoint owns continuation; the existing reader theorem remains the positive native boundary.

1. Exact problem and useful conclusion

The input remains right-first ordinary Horn records (-01v,+1w);, then left records (-00u,+01v);, then pins (+00a);(-1b);. Names are nonempty binary strings; leading zeros matter. Right S is functional, with arbitrary finite domain, arbitrary target lengths and arbitrary many-to-one fibres. Left R has arbitrary fanout. SAT means there is no selected v with (a,v) in R and S(v)=b. Empty blocks, duplicates and missing names retain their existing meanings. Functionality must be checked, not promised by a free table oracle.

Actual length is

N = sum_right(9+|v|+|w|) + sum_left(10+|u|+|v|) + 11+|a|+|b|.

These counts include the written namespace prefixes and punctuation; any section12 phase delimiters add their fixed actual number. All resource conclusions use the actual complete encoding, with no padding.

A fixed native machine must have finite labels/control, fixed degree/radius, old-top update semantics and fixed initialization. All parsing, right preparation, code construction, allocation, old-storage observations, ordinary-name routing, retained history and query work count. There is no supplied decomposition, code, handle, address operation, pointer-identity channel, padding or EOF work. A whole-record work bound does not establish a per-symbol deadline. Any eventual native recognition theorem transfers to a PEG for reversal of the complete language only.

The useful positive conclusion is geometric, not operational: a common binary routing tree can always give each target a route of length at most 2|w|+3 and at most 2|v|+3 for every v mapping to it. Thus arbitrary length ratios do not themselves force a long common route. The unresolved resource is obtaining and maintaining that route in time, coherently across source versions.

2. Offline weighted routing construction

Let V be the finite domain of S and W its image. Put

rho(z) = 2^(-2|z|-2),
alpha(w) = rho(w) + sum_{v in V:S(v)=w} rho(v).

Over all nonempty binary strings, sum rho(z) = (1/4) sum_{n>=1} 2^(-n) = 1/4. Functionality ensures each v appears in exactly one fibre. Hence sum_{w in W} alpha(w) <= 1/2, even with arbitrarily large inverse fibres. Both alphabets are the ordinary binary-name universe, not finite-width advice.

Order W lexicographically. Lay consecutive disjoint half-open intervals I_w of width alpha(w) in [0,1/2). For each interval, choose d_w to be the least nonnegative integer with 2^(-d_w) <= alpha(w)/2. The dyadic grid cell of that width containing the interval midpoint lies within I_w: either end of the cell is at distance at most its width from the midpoint. Its d_w-bit binary address is c(w). The cells are disjoint, so the addresses are prefix-free and follow the same lexicographic order.

Because alpha(w) >= 2^(-2|w|-2), we have d_w <= 2|w|+3. For every S(v)=w, alpha(w) >= 2^(-2|v|-2), giving d_w <= 2|v|+3 too. Empty S gives the empty code family. No assertion depends on a numerical logarithm instruction of a native machine.

The ordinary finite binary trie of these codes has at most 1+sum_w d_w nodes, fixed labels and degree2. Choose one representative v for each w to see that this is O(1+sum_{v in V}|v|), also O(1+sum_{w in W}|w|). Store one code-word receipt per w and aliases from ordinary-name dictionaries for v and w. Their abstract storage is O(N_right). Codes may share common initial zero bits; removing those is optional and not used in the bound.

This is a self-contained elementary interval-packing argument. It uses global ordering and exact rational arithmetic offline. No linear-time preprocessing algorithm, end-of-right-block construction deadline, or constant-time arithmetic is asserted. The code can change when S is extended. Building it after the phase ends is not permitted in the native problem without a separate charged schedule.

2.1 Injective tables avoid global code construction

For injective S there is an even simpler stable code. Encode a nonempty word z by replacing0 with00 and1 with01, then appending11; call this e(z). This is prefix-free and has length2|z|+2. For the pair S(v)=w, put c(w)=0e(v) if |v|<=|w|, and c(w)=1e(w) otherwise. Inside the first lane, injectivity/functionality make selected v distinct; inside the second lane, targets are distinct. Different lanes have different first bits. The codes are therefore prefix-free, stable under injective extensions, and have length2 min(|v|,|w|)+3. No alphabetic order is asserted or needed for membership tries.

Their receipts can be prepared during actual right input with existing local primitives. Retain the actual v bits in a FIFO and a unary length stack while its ordinary dictionary path is opened. While w arrives, retain its bits and pop a saved v-length counter until exhaustion; at the delimiter, a finite flag tells whether |v|<=|w|. A receipt is a tag plus the selected raw-word FIFO. A code reader emits the tag, two fixed bits per raw bit, and11; it does not materialize an uncharged string. Store the receipt in both v- and w-keyed frozen dictionaries, suspending the v path while the w path is processed. All raw words and counters cost O(N_right), with fixed parallel builders/cursors.

The actual right table can be checked for functionality and injectivity without pointer equality. D(v) retains its previous target word, if any. Compare it during w, with exact exhaustion. In parallel W(w) records whether that target was seen. Reject an old v with a different w, or a previously unseen v with an already seen w; an identical repeated pair is allowed. Both dictionary closures and the finite receipt selection occur at the delimiter. The usual finite syntax controller rejects malformed/stopped records. This is a bounded-local receipt-preparation routine using established capsules/FIFOs, not a recognizer for the subsequent composition problem.

This removes offline sorting as the explanation for the unresolved injective case. It does not remove late availability: a left update cannot in general know the lane or selected shorter word until D(v) resolves, and a query cannot know its inverse receipt until W(w) resolves. In the expansion-only case |v|<=|w|, updates can already use e(v) directly; the entire remaining difficulty is consulting the selected source’s version while the target name arrives. That is the cleanest next test.

3. What the code-ready representation would buy

Suppose c(w) were an already available streamed key during an update selecting v and during a query naming w. Store, for each source u, an immutable membership trie M_u over these codes. Selecting v adds c(S(v)); a missing v does nothing. Querying b tests c(b), rejecting product membership if b is outside W. After every completed update,

M_u = {c(S(v)) : (u,v) in R and v in V}.

Injectivity of the prefix-free codes proves exact membership, including duplicates and many-to-one fibres. Ordinary capsule tries preserve old versions and permit suspended outer source paths. Conditional on timely key streams, the total code bits processed during left updates and queries are O(N_left+|a|+|b|). Path copying retains O(N) logical records after the offline dictionary is installed. No full relation product or long target spelling need be copied for each selected edge.

This is an abstract code-ready upper bound, not a native result. If the code FIFO becomes available only when the v or b dictionary lookup finishes, its subsequent O(|v|) or O(|b|) traversal is additional work after the relevant bits have arrived. The strict FIFO gives cheap operations once a root is available; it does not retroactively pay for those operations. Prior simultaneous-record compilation cannot compile an unbounded batch at a delimiter.

The distinction also rules out a naive communication objection: these are jointly prepared dictionaries, and earlier right symbols may legitimately prepare shared routes. An independent-store lower bound cannot discard that preparation. Conversely, offline short routes do not supply any of it within the native deadline.

4. Four construction attempts and their exact failures

A. Decode the inverse at the target leaf, then test the source row

On the injective subcase, prepare b -> v in the right block, store selected v in the source row, and look up the inverse during b. This avoids explicit long-target insertion, but the generic dictionary returns its payload at the end of b. A bitwise interpreter then needs |v| steps, or |c(b)| steps in the coded variant, to query M_a.

For the terminal-only payload, sequential interpreter contract, if at most r route edges can be followed per remaining input symbol and only c punctuation symbols remain, any returned route deeper than rc misses the deadline. Arbitrarily many distinct targets require unbounded maximum prefix-code depth. This rules out that interpreter even though each depth may be O(|b|). It is not an information or native lower bound. Work done speculatively while b arrives, a prepared answer rather than a spelling, or a more direct coupled traversal escapes its premise. The clock time available during a long common prefix cannot be thrown away in a general negative argument.

Large inverse fibres create an additional problem: an inverse payload is then an unbounded set, not one predecessor. The weighted code construction avoids that semantic multiplicity by assigning one code per target, but has not solved timely code delivery.

Reopen gate: give a prefix-by-prefix coupled reader that obtains the current source’s Boolean answer while consuming the actual target spelling. Returning a code or predecessor at the leaf is insufficient.

B. Compress a global target prefix and rewrite old suffix receipts

Suppose m right targets begin with 0^L and have distinct short suffixes. They can be represented by one shared prefix and m suffixes. A later target beginning in1 makes the global common prefix empty. An implementation that eagerly replaces all prior suffix receipts with complete new suffix spellings must write at least mL prefix bits. The final short right record cannot pay that cost for unbounded L, even though the earlier right block was long.

This refutes only eager materialized rebasing at the shortening record. Immutable concatenation contexts can keep (prefix,suffix) without copying the prefix; the finite checker explicitly retains that escape. Such contexts preserve strings, but do not alone give coherent source-specific membership lookup in a changing compressed index. A return to literal suffix copying would repeat this failure.

Reopen gate: retain shared contexts and prove the current-version query traverses them with bounded work per actual bit, including a late shortening, prefix names and old aliases. Earlier paid preparation is allowed, but its exact representation and work must be shown.

C. Put mutable source marks behind frozen target aliases

A frozen target leaf pointing to an old source-membership root does not follow a later immutable update. Copying the source root creates a new version; the target alias still points to the old one. This is a coherence failure even on a one-element example, not a size issue. Replacing the pointer by an ordinary source name introduces a second lookup whose availability and length must be charged; replacing it by a numeric address or global mutable cell changes the native contract.

Reopen gate: name the current-version root explicitly and explain how both update and query reach it within their input schedules. Old versions should remain valid old snapshots, rather than silently acquire new values.

D. Freeze one short common code per target as new preimages arrive

The weighted construction cannot in general be made append-stable while keeping a bound |c(w)|<=A|v|+B for every later preimage, for fixed A,B. Choose an integer K>=A+B and more than2^K initial distinct targets, each reached by a distinct intermediate name of length greater than1. At most2^K distinct prefix-free codes can have length at mostK. Some target therefore receives a longer code. Now append the unused one-bit intermediate0 mapping to that target. A frozen code violates its required bound. The final table is functional and has inverse degree at most2.

This rules out one immutable prefix-free code per target, satisfying all later preimage bounds. It does not rule out rebasing, alias codes, multiple representations or answering a predicate without following a common code. Nor does it rule out the stable injective scheme in section2.1: the last step deliberately adds a second preimage. A checker also exhibits instability of the specific weighted construction: {‘0’:‘1’} codes target1 as0001, while extending it by {‘1’:‘0’} changes that code to0011. The general argument, rather than that example, establishes the frozen-code limitation.

Reopen gate: handle aliases or rebasing with explicit current-version routing; do not assume the offline common code stays fixed when a short new preimage arrives.

5. Combined attack and next decisive test

Combining these ideas does not yet close the problem. Shared contexts avoid copying long target prefixes. Weighted routes avoid a static path-depth mismatch. Stable local codes even remove offline construction in the injective case. None tells a target-side reader how to consult the selected source version when a route is disclosed only at a terminal leaf. A dynamic marker hidden behind a frozen alias reintroduces the coherence failure. Arbitrarily many unresolved pending routes cannot simply be compared in parallel by a fixed machine.

The next target is therefore a dual-name, version-coherent marking interface, first on injective expansion tables with |v|<=|w|:

1. During actual right records, construct a shared routing structure. No offline sorting or phase-end normalization is free.
2. An actual left name v selects a target mark in the current source version. Marking may be deferred only if every completed boundary already has an exact query predicate.
3. A late actual target name b follows a reader that tests that current version by the final punctuation, without receiving v or c(b) merely at its last bit.
4. Charge all cross-links, suspended contexts, speculative readers, rebasing, routing, observations and persistent allocation. Give fixed degree/radius/control and O(N) logical history, then invoke the existing compiler only after the local schedule is complete.

A concrete test family is an arbitrary injective table between short names and long names with shared prefixes. The contraction-oriented counterpart remains a separate subsequent test. These are not impossibility witnesses: length-compatible arbitrary permutations already succeed, and a finite terminal image already succeeds at arbitrary scales. Any proposed interface must recover those controls and handle duplicates, absent names and retained old versions.

A positive solution for injective tables would be consequential even before unbounded fibres: it would separate changing access coordinates from union over many predecessors. If it fails, record a representation-independent resource invariant; terminal-only decoding and eager rebasing failures are not such invariants. The native SAT boundary remains open.

Structural separation retained from this attempt

For each source row A, the desired answer at w is whether A intersects the fibre S^{-1}(w). An injective table has singleton fibres, so this is purely a change between two ordinary naming systems for the same marked object. General functionality additionally requires aggregation over a possibly unbounded fibre. The two-lane code isolates the first task; it is not automatically a solution to the second. Assigning a different short code to every short preimage would require the target query to aggregate those codes, rather than merely follow one.

This explains why the existing positive controls must remain separate. Bounded left selection bounds the number of completed predicates queried. Finite terminal image bounds the answer summary. Fixed streaming maps expose the needed coordinate during input. Length-compatible pending overlays provide both timely routing and bounded unfinished work. None of those statements is merely a storage bound. The present attempt adds a useful negative diagnosis of the proof strategy: even when an abstract short common route exists, its current-version readout schedule still needs proof. The next injective expansion test removes fibre aggregation so that a failure cannot be attributed to it prematurely.

6. Evidence, review and seven-surface disposition

tools/research/check_cross_scale_routing.py uses exact rational cells and independent direct set-image answers. It checks all256 partial functions from four names to three targets (including a31-bit target), plus20 expansion/contraction/fibre/common-prefix families. It checks code prefix-freedom, disjoint ordered cells, both length bounds, and2048 retained selection snapshots with10240 membership comparisons. It also contains12 arithmetic deadline witnesses,12 eager-rebase budget witnesses and one stale-alias counterexample and one unstable-code example. It also checks the stable two-lane injective code on all finite injective cases in its family. The arithmetic witnesses are contract checks, not executed native workloads. Python sorting, numeric addresses, dictionaries and strings are deliberately offline mathematical models.

Writing-agent proof audit: the global mass bound counts each v once because S is functional; no bounded inverse fibre is assumed. The target’s own mass gives the query-side bound even for a very long preimage. A cell of width at most half an interval fits around its midpoint. Disjoint dyadic cells imply prefix-freedom; many-to-one fibres deliberately share one code. Snapshot membership uses a separate set-image oracle. The abstract representation’s storage bound counts the code words and all path copies, but its code construction and availability are explicitly unproved at native deadlines. No independent review or formal replay is claimed.

Scheduled32->33 once for a completed no-native-advance assessment. Mathematical91/window5/last reassessment86 remain unchanged: the elementary coding observation is a supporting step in this unsuccessful construction attempt. Next substantive result92 still requires the six-result reassessment. Next scheduled34 is research; dedicated review35 remains due. All prior SAT, affine-fragment, replay, persistent-causal and unary-cubical frontiers remain intact. Those controls distinguish cheap storage, completed local readout and coherent composition; none grants an uncharged coordinate change here.