Shared traversal and selector-index routing

13 October 2026. A written routing calculation and failed native extension. At assessment 236, construction 80 was the latest native result; no root admission or new language lower bound.

Construction 81 subsequently supplies earlier paid short-key activation indexes for the sparse family. The restricted routing and explicit-path failures below remain valid for their stated representations. Construction 82 extends the shared-index mechanism to namespace-specific cuts under its per-namespace seed restriction. The current checkpoint records the surviving target.

Outcome and concrete example

Completing a shared task tree once does not, by itself, build a cheaply accessible index of its answers. The index has its own traversal order. For a single zipper that installs completed answers in task order, its exact navigation cost is twice the total number of runs occupied by selector subtrees in that order. This separates shared task work from the work of arranging its results for later ordinary-name access.

For four tasks completed in binary order 00, 01, 10, 11, suppose their selector names are 00, 10, 01, 11. The task traversal is a depth-first walk. The index writer repeatedly crosses the selector root. At depth n, reversing all n-bit names makes this contrast grow: the task walk costs $4\cdot2^n-4$ edge moves, while the selector walk costs $2n\cdot2^n$. These are costs of this explicit implementation, not costs forced on every persistent representation.

The simplest repair is to require every selector subtree to occur in one contiguous interval of task order. That permits a linear two-stack construction. But on full equal-depth binary tries with a bijection, this condition is exactly a prefix-tree automorphism, an earlier control. It does not extend the known native frontier. The remaining target is a paid producer for a broader correspondence, including construction, current-version service and final selector access.

The starting points are the optimistic service game, the scheduling/synthesis comparison, and construction 80. This note tests their missing cross-index operation rather than repeating their semantic bridge.

1. The route being tested

Let T be a finite rooted binary task tree. Its leaves are distinct tasks whose completed payloads are cursors or marks from one captured activation version. Task edges are traversed using a stack in a fixed depth-first leaf order $x_1$ through $x_M$. Let Q be a rooted binary selector trie with M leaves, and let pi be a bijection from task leaves to selector leaves. Put $y_i=\pi(x_i)$.

The proposed writer has one zipper in Q, initially at its root. When the next task payload is ready, it walks to $y_i$ and installs the payload. It returns to the root after the final payload, so the constructed index is ready before its query begins. Each parent or child edge move costs one navigation job. Following the unique shortest tree path is optimal under this stated movement contract. No arbitrary-node jump, retained alternative index cursor, numeric address or backpatch is part of that contract.

This isolates routing generously: it grants the writer knowledge of the next route. Discovering $y_i$ from ordinary records, validating pi, maintaining immutable payloads and obtaining the current task cursor are additional work. Consequently the navigation count is a lower bound for this particular writer even with free route knowledge. It is not a native lower bound: cached roots, threaded links, other indexes, a different task order or aggregate predicates can leave this contract.

All Q leaves here are distinct and form a prefix-free set. Sparse and unequal-depth tries are allowed unless a later statement explicitly assumes the full depth-n tree. No EOF work or free time before the service interval is inferred from this abstraction.

2. Exact routing variation

For each nonroot Q vertex v, let $r_v$ be the number of maximal contiguous runs of indices i for which $y_i$ is in v’s subtree. Every Q edge lies on a route to a supported leaf, so $r_v\ge1$. Define

$$F_Q(\pi)=\sum_{v\ne\mathrm{root}}r_v.$$

The shortest walk from the root through $y_1,y_2,\ldots,y_M$ and back to the root has length

$$V_Q(\pi)=2F_Q(\pi).$$

Proof: delete the edge above v. The walk starts and ends outside the v component. Each run of destinations inside that component requires one entry and one exit. No extra crossing is needed when consecutive destinations lie on the same side. The concatenation of unique shortest paths realizes exactly these crossings, independently for every edge. Sum over edges. Thus

$$V_Q(\pi)\ge2|E(Q)|,$$

with equality exactly when every subtree’s destinations occupy one interval. More generally this writer has linear navigation in the size of Q exactly when $F_Q(\pi)$ is linear in that size. This is a total-work equivalence for a fixed order, not a strict deadline criterion.

For a full depth-n Q, an equivalent formula is

$$V_Q(\pi)=2n+\sum_{i=1}^{M-1}\bigl(2n-2\operatorname{lcp}(y_i,y_{i+1})\bigr),\qquad M=2^n.$$

The lcp expression is used in the proof and finite oracle, not claimed to be a constant-time native instruction.

Full reversal is expensive for this writer

Enumerate the n-bit task leaves lexicographically and set $y_i$ to the bit reversal of x_i. Consecutive binary integers have opposite last bits, so consecutive $y_i$ have opposite first bits. Their lcp is zero. Hence $V_Q=2nM$. The task tree itself has 2M-2 edges and a complete DFS walk of length 4M-4. A serial task-and-index walk therefore pays at least their sum before payload installation, pointer allocation or correspondence discovery. Counting only the task union misses a logarithmic factor in M for this route.

This does not rule out whole-suffix reversal natively. Nor does it transfer entry 129’s matching or positive-path theorem: those imported results retain their separate contracts and growing alphabet. Here the selector is an ordinary binary string, and the conclusion concerns an explicitly restricted index writer.

3. Why the minimum-cost repair is an old control

Assume both T and Q are full depth-n binary trees, task order is lexicographic, and pi is a bijection. Then the following are equivalent:

1. Every Q subtree occupies one interval of task leaf order.
2. Pi is induced by independently choosing whether to exchange the two children at each internal task node.
3. $V_Q(\pi)=4M-4$.

The first and third are equivalent by the crossing formula. For the first-to-second implication, the two root-child preimages are disjoint intervals of M/2 leaves covering the entire task order. They must be the first and second halves, in either order. These halves are precisely the two task-root subtrees. Repeat inside each half. At every node the two equal-size child intervals must be its two task-child blocks, possibly exchanged. Induction reaches the leaves and supplies the claimed tree automorphism. Conversely an automorphism maps each selector subtree back to one task subtree, which is contiguous in DFS order.

There are $2^{M-1}$ such permutations, one independent swap choice at each of M-1 internal nodes. This is a combinatorial count, not a claim about the bits needed by a native representation.

The earlier namespace frontier already preserves prefix-tree automorphisms as a control. Recognizing this collapse prevents calling the cheapest zipper alignment a new variable-width native construction. Allowing a constant-factor excess of runs is potentially broader; its producer and deadlines remain unresolved. For sparse or unequal-depth trees the full-tree equivalence above is not asserted.

4. Linear total routing can go beyond fixed envelope width

The preceding collapse concerns the minimum, not all linear routing. Here is a broader family that tests whether a constant-factor allowance helps. Let $n=2^l$ with $n\ge8$ and M=$2^n$. In the full n-bit domain define disjoint sets

$$A=\{0^{n-l}t:t\in\{0,1\}^l\},\qquad B=\{t1\,0^{n-l-1}:t\in\{0,1\}^l\}.$$

They are disjoint because the displayed 1 in a B word is within its first n-l positions, where every A word is zero. Pair equal t values, exchange the paired A and B words, and fix all other words. This is an involution changing exactly 2n leaves, so task-to-selector and selector-to-owner orientations give the same map.

Changing one destination in a closed tree walk changes its two incident distances by at most twice the distance between the old and new destinations, at most 4n. Applying this one position at a time gives

$$V_Q(\pi)\le4M-4+8n^2\le12M-4.$$

The last inequality uses $n^2\le2^n$ for $n\ge8$. Thus this family has linear total navigation, uniformly in n.

Nevertheless it lies outside every fixed pair (C,W) of construction 80’s suffix envelope-width contracts. At the input prefix $p=0^{n-l}$, j=n-l, its n possible completions are exactly A. Their images have all n distinct first-l-bit prefixes. For any fixed C and all sufficiently large n, the envelope length $e_C(j)=n-Cl$ is at least l. Hence there are n distinct envelope prefixes at p, exceeding any fixed W. This compares only the suffix-table conditions. It does not prove exclusion from every earlier native class or give a new native implementation.

This family rules out dismissing all low-fragmentation correspondences as automorphisms. But its partial traversal proposal also fails, as follows.

The same witness fails the mandatory-work cut

At $p=0^{n-l}$, the n possible selected owner words are all B words. Their first l bits form a complete binary tree; after each such prefix is a private tail of length n-l. Allow K beta-edge jobs per remaining actual symbol and H=l+d remaining symbols, where d is any fixed allowance for punctuation. The mandatory-prefix cut requires, whenever $n-K(l+d)>l$,

$$R=(2n-2)+n\bigl(n-l-K(l+d)\bigr)$$

completed beta edges before this cut. This already grants free owner discovery and cursor retrieval and ignores the common alpha/setup work. The equation counts the entire depth-l branching tree and the mandatory part of each disjoint tail.

For fixed K,d, R grows quadratically in n. All post-capture actual symbols before the cut in construction 80 contribute only O(n) service, including E(c), a and the consumed z prefix. For every fixed coefficient A bounding this earlier budget by An, R>An for sufficiently large n. Hence selectively preparing just these n candidate paths cannot finish in this fresh explicit-path scheme either. Whole-index materialization and partial candidate traversal fail for different, explicitly counted reasons.

This applies the established service cut to the new routing witness, not a new universal lower bound. A prepared current predicate that bypasses the private tails escapes the path contract. The concrete surviving test is to exploit the structured tails during earlier ordinary activation records, constructing a shared shorter current-answer index with paid routing and validation. The longer names must remain actual data, not padding, and the index cannot be supplied as advice.

5. A conditional immutable construction, with its bill exposed

The interval condition does solve a narrower implementation problem. Suppose task and selector trees, their association, the next local routing choice and the captured activation root have already been obtained by charged operations. Suppose further that an actual preselection interval pays the following whole traversal before selector lookup starts.

Use one persistent stack for T’s DFS and one for Q’s DFS. Each Q frame stores its template node, finite child-status flags, a completed-child result and its parent continuation. A completed task payload becomes a fresh Q leaf. When its Q subtree finishes, create its immutable parent with the completed child results and return it to the parent frame. The interval condition ensures that an exited completed subtree is never visited again. Visiting the other child later uses the frame still on the stack. Each edge move, frame operation and constructor has bounded local cost and fixed pointer arity. The two stack roots and the currently produced payload suffice; stack depth is stored in nodes, not finite control.

The complete construction uses O(|E(T)|+|E(Q)|+M) logical operations and fresh records, including both final returns to the roots. It constructs a fresh directory for that captured version, rather than rewriting a static selector leaf to point to a future cursor. Afterwards the ordinary selector follows Q one edge per bit and reads its leaf payload. Old versions are immutable. This is a conditional bounded-degree graph procedure, not a new native language theorem or a claim that two supplied roots are free.

Its missing hypotheses matter. A scheduler must pay task discovery, selector instructions, input-derived association, both stacks, allocation and setup after the current version is known. The last ascent may have unbounded depth and is explicitly included before lookup, not hidden in final-symbol work. The operation count is not automatically a per-symbol schedule. No field may be added merely as padding to fund it. A native transfer must identify the real ordinary-record symbols paying these operations and finish at every required cut. The physical old-top compiler and N+1 scaffold claim are deliberately not invoked for this unfinished transfer.

The ordinary query window rejects full fresh materialization

For a full n-bit suffix table, the stated fresh builder allocates at least M=$2^n$ payload leaves per captured version. Using construction 80’s ordinary record shape, take r=n, m=2n+1 and a fixed-length source pin. The actual query after the source version becomes available consists of E(c), a, z and fixed punctuation, only O(n) symbols. A fixed native batch allocates only O(n) records in that window. Thus this full fresh-index procedure cannot meet those query deadlines for unbounded n, even on an interval-compatible table and even with free static routing instructions. Its total O(M) cost cannot be charged to the already consumed right-table symbols.

This is an allocation bound for the explicitly fresh-per-query procedure, not an information-size or language lower bound. Earlier paid construction while processing left records, structural sharing of current answer subtrees, partial materialization, or aggregate predicates can leave the procedure. They must explain how the selected source version and growing namespace correspondence remain accessible. The argument does not erase service before the cut in the optimistic game: it specifies a procedure that starts the fresh directory only after capturing that version, then counts all actual remaining symbols.

6. Three repairs examined and why they do not close the target

Static cross-links. A selector leaf can point to its static task template after paid preparation. That is not a pointer to the later current-version cursor produced by traversing that template. Immutable old nodes cannot acquire links to future allocated nodes. A fresh association list of template/cursor pairs stores the answers, but still needs a paid lookup from an ordinary selector. The failure is not an information-size argument and does not prohibit a different persistent dictionary. Reopen with a constructed, timed lookup operation; do not identify template identity with an addressable current answer.

Change traversal order to match selectors. This removes selector fragmentation but transfers it to task access. For the full bit-reversal example the inverse is again bit reversal, so a single task zipper visiting selector order also costs 2nM. Alternating which zipper is considered free does not repair this example. Other joint orders, multiple cursors or an aggregate computation remain possible and are not bounded by this argument.

Build the index in a later sweep. A second pass can be linear if completed payloads are already in selector order. Producing that order is exactly the disputed cross-index operation. Following static selector-to-template links only retrieves static nodes, not current payloads. Following fresh backward links from payload to selector does not create reverse links. A lookup structure, a paid reordering pass or a locally maintained frontier is required. No uncharged final sweep is allowed.

These attempts leave a precise failure gate: the union of completed task edges omits the work of turning version-dependent results into a locally accessible selector index. The conditional interval construction makes that work explicit, but its full-tree minimum case reproduces an old control. A sparse-exception family has linear routing beyond every fixed envelope width, yet constructing its full fresh index is too expensive in the ordinary query window. This is a sustained failed extension, with a reusable routing calculation, rather than an advance in native language recognition.

7. Evidence, controls and next decisive test

The standalone checker compares explicit zipper edge movement with independently counted subtree runs. It enumerates all permutations through depth three, checks the automorphism equivalence and extrema, tests irregular prefix-free tries, checks growing identity/reversal families, and checks the sparse-exception witness and its envelope widths. These are finite semantic/navigation checks; they do not simulate native timing. The assessment record records actual counts, review and publication scope.

Construction 80’s fixed-width workers remain valid. Replay slices still charge replay; affine joins retain their coordinate hypotheses; persistent causal sharing retains old states without giving inverse links; unary coherent algebra gives no growing selector index. Native SAT controls still require ordinary late pins, actual support, the captured current source version and final-symbol negative readout. Native recognition would give a PEG for the reversed checked language, not automatically its input orientation.

Next test at assessment 236: test an input-built current-answer index for the sparse exchanged-leaf family that contracts its structured private tails during ordinary left activation records. Charge construction, shape validation, shared source-version updates and late selector routing; determine whether growing namespaces can reuse that index without per-namespace updates. The fresh full-index and partial explicit-path routes are now closed for this family under their stated contracts. Preserve arbitrary whole-suffix permutations, arbitrary-name routing, cyclic sharing and heterogeneous service as open.