Context names can destroy a cheap union geometry

12 October 2026. Assessment 213. A failed aggregate extension and a structural transfer criterion. Native construction 70 is unchanged.

Result and payoff

A row may be a complete prefix cone before coding and a highly fragmented set afterward. The immutable codes in construction 70 preserve membership and ownership. They do not, by themselves, preserve the mixed-region budget needed to replace a bounded tuple of targets by one cheap aggregate.

The example below turns one mixed prefix into exponentially many mixed coordinate occurrences. Every right row is a complete clipped cone, and ordinary input learns all contexts. Thus cone completeness and unique ownership do not close the aggregate extension. The obstacle survives after removing the common code stem and after sharing identical physical records.

The useful positive condition is that a coordinate change have bounded congestion at prefix cuts. We prove the precise finite-tree statement, then separate it from the still-unpaid native routing and pending-union operations. This is a representation-specific failure and a conditional geometric transfer, not a native-language lower bound or a new numbered native theorem.

1. Which budget is being tested?

For a set $X\subseteq\{0,1\}^n$, let $P_n(X)$ count proper prefixes $p$ whose cylinder contains both an element of $X$ and an element outside $X$. These are the BRANCH coordinate occurrences in the canonical EMPTY/FULL/BRANCH tree. Repeated uses of one physical record count separately.

This is the content geometry used in reader 32.7. It is not the radial length-profile mixed count in theorem 66. A singleton depth profile can be cheap while its content slice is expensive. A code must preserve the budget in the coordinates where the intended merge actually runs.

For a single prefix cone of fixed width, $P_n(p\{0,1\}^{n-|p|})=|p|$. In particular, the left half of a cube has mixed count one. The unchanged prefix-tree splice proof charges expansions to these mixed coordinates. An injective relabeling preserves Boolean union, but need not preserve that charge.

2. A complete-cone ordinary-input witness

Fix $D\ge1$ and put $K=2^D$. For $0\le t<K$, define the $D$-bit word

$$P_t=(t\bmod2)\,\operatorname{bin}_{D-1}(\lfloor t/2\rfloor).$$

The zero-bit suffix when $D=1$ is empty. Feed the following ordinary right records to the greedy context producer:

1. For alias 0, first give targets $P_t00$ in increasing order of $t$.
2. Complete this same row to every binary word of length $D+2$.
3. For alias 1, give every binary word of length $D+2$ beginning with 0.

There is no supplied context, code, decomposition or succinct cone descriptor. Every required target occurs literally. The first completed row is the full cube; the second is its left half. These are complete clipped cones, both sibling-closed, with one occupied depth. Repetitions are unnecessary.

The creator alias has length one, so the greedy rule removes two final bits and creates exactly $P_t$. Earlier contexts have the same length and are distinct, so none matches the next creator target. Once all contexts exist, every later target has exactly one owner, its length-$D$ prefix, and residual length two. Every alias/residual class difference is one. Completing the creator row introduces no further context or class code. The test row uses the already-created codes.

To isolate geometry, provisionally generalize the ordinal code with the finite family parameter $d_D=4K$. This would give

$$b=D+3,\qquad C_t=0011\,\operatorname{bin}_b(t).$$

This is a diagnostic family, not one fixed automaton with growing degree or control. Construction 70 retains its fixed degree bound. We even grant the larger codes for this test; their unpaid cost is an additional issue, not the proof of the geometry failure.

The first $K$ distinct creator targets occupy exactly slots $0,\ldots,K-1$. All later occurrences of a context/class pair retain that first code. The image of the test row is therefore

$$Y_D=\{0011\,\operatorname{bin}_{D+3}(t)y: 0\le t<2^D,\ t\text{ even},\ y\in\{0,1\}^2\}.$$

Its literal preimage has $P_{D+2}=1$. In the code cube the first seven bits form the common stem 0011000. Each of its seven proper ancestors is mixed. Below that stem, every ordinal-prefix coordinate of depths zero through $D-1$ is mixed: both parities still occur. At an ordinal leaf, the residual cube is either wholly present or wholly absent, so it contributes no mixed coordinate. Consequently

$$P_{D+9}(Y_D)=7+\sum_{i=0}^{D-1}2^i=2^D+6.$$

Even if the seven-bit stem is removed, the count is $2^D-1$. There are $2^{D-1}$ mixed parents immediately above the ordinal leaves. Thus no fixed constant preserves a linear-in-width mixed-prefix budget under this coding, even for these complete cones.

All identical parity subtrees can be shared. Only $D+7$ distinct BRANCH records are then needed, but the unfolded mixed count is unchanged. The result refutes the proposed transfer of the existing coordinate-charged splice bound. It does not prove that every implementation must expand those coordinates; a parity predicate, for example, can summarize this particular image.

The parity pattern is only a convenient witness. For any subset $B$ of exactly $K/2$ ordinal positions, choose a creation order with $P_t$ beginning in 0 exactly when $t\in B$, bijecting each half separately. The same two complete literal rows then have transformed test row $B\times\{0,1\}^2$ after the common stem. Thus arbitrary balanced masks occur solely from input order. A fixed parity shortcut cannot cover all such orders. This is a semantic representation fact, not a hardness theorem or a claim that preprocessing cannot retain the literal cone.

The right input here has $6K$ target records and actual length $(D+12)6K$, using the right-record cost $9+|v|+|w|$. A later single selection and pin have their ordinary additional cost. The large preparation block is real input, not padding or free preprocessing. The conclusion is not a total-time lower bound: paid preparation might build a better aggregate. It is the failure of a claimed structural budget implication.

3. A precise geometric transfer criterion

Let $\phi$ be a permutation of the leaves of a full depth-$D$ binary tree. For each proper output prefix $r$, let $a_\phi(r)$ be the longest common prefix of the input leaves whose images extend $r$. There are at least two such leaves, so this is an input internal node. Define its prefix-cut congestion by

$$g(\phi)=\max_p\#\{r:a_\phi(r)=p\}.$$

Conditional geometric transfer. For every $X\subseteq\{0,1\}^D$,

$$P_D(\phi(X))\le g(\phi)P_D(X).$$

Proof. If output prefix $r$ is mixed, its preimage contains both an input leaf in $X$ and one outside $X$. Both extend $a_\phi(r)$, so that input node is mixed. Charge $r$ to that node. At most $g(\phi)$ output prefixes charge any one input prefix. Counting the charges proves the inequality. No algorithmic cost for computing this map has been assumed.

A depth-preserving rooted-tree isomorphism, allowing independent left/right swaps at each node, maps cylinders to cylinders. It has $g=1$ and preserves the mixed count exactly. Adding a common code stem of length $c$ adds at most $c$ mixed coordinates. Replacing every selected leaf by its full two-bit residual cube adds none. Thus these transformations preserve the relevant geometry with an explicit additive stem cost.

The witness’s map sends an input prefix word $P_t$ to the $D$ low ordinal bits of $t$. Every proper output cylinder has both possible first input bits. All $2^D-1$ output prefixes charge the input root, so $g=2^D-1$. The left-half row attains the transfer bound. The obstruction is therefore a concrete congestion of independently relevant prefix cuts, not a failure of semantic injectivity.

For the witness alone, codes $C_P=0011P$ instead give mixed count five. However, these codes have length $D+4$, while the residual has length two and the selection alias has length one. They fail construction 70’s residual-funded decoding and compatible-length pending-receipt interface. Preserving geometry solves one obligation and exposes another.

4. Why two natural aggregate repairs do not yet close the construction

Keep creation-order codes and compress identical nodes. This retains exact answers and can save storage. It does not recover the unfolded mixed-coordinate bound. A specialized shared-DAG merge or a richer Boolean predicate might avoid expansion, but its update work, effect on old pending jobs and negative readout must be proved separately. Counting unique records is not that proof.

Use literal-prefix codes and let the query pay. The query contains the original context prefix, so it can fund a traversal that consumes those symbols. This is a promising difference from the short residual-only reader. But a short alias selection still releases a long aggregate route. The assessment 206 common-stem family already rules out a dispatcher that traverses every long stem before globally sealing the relevant band. Paying the query’s route does not retroactively pay all selected rows’ routes. A static row handle also does not identify the current source-specific union.

The finite cut-congestion inequality supplies no free native LCP, routing map, code lookup or geometric decomposition. For arbitrary nested contexts, ownership also removes descendant regions from ancestor predicates. Any richer aggregate must represent those holes in the same coordinate universe as its FULL/EMPTY tests. The equal-depth counterexample has no nested holes, so solving only that complication cannot remove the failure above.

The ordinary-input producer remains an independent obligation. These witnesses really are complete cones, but that fact in a proof is not a native validator for arbitrary candidate input. Sibling closure alone does not certify every descendant or a gap-free depth interval. A future theorem must build and check its aggregate, not receive it ready-made.

5. Next decisive test and resource contract

Subsequent work. Frozen-support construction 71 completes a support-first version of the shared-coordinate test below. It requires an actual initial row to prepare a support that remains fixed; it does not establish the proposed aggregate extension of construction 70. Its next target is charged support expansion that preserves old row meanings and local views. The paragraph below records the assessment 213 target.

The next target is a shared literal-prefix aggregate with source-specific pending selection, first for equal-depth contexts and sibling pairs. This diagnostic isolates the routing/selection conflict without nested ownership holes or future interval activation. Include both the common-stem selections of assessment 206 and the arbitrary creation orders above. Require a bound on the new selection’s entire truncated residual work, including disturbance of older jobs, or construct a direct counterexample to the proposed bound. Then restore nested contexts, clipped depth intervals and their checked completeness producer.

Any successful native realization must fix degree, radius, finite labels/control, initialization and old-top update semantics. Count the actual right-first Horn length, ordinary alias/source/query routing, preparation, old observations, allocation, pending work and output. Answers must be ready per actual symbol and at the final symbol, with no supplied decomposition, ready external handles, padding, advice, identity/address/metadata/timing side channels or EOF work. A native recognizer would imply a PEG for the reversal of its complete checked language. This note supplies no new such recognizer.

This is a follow-through on the aggregate test after construction 70, not a restart of the semantic Horn bridge. Imported entry 129 state/port bounds and their growing alphabet remain unchanged. Replay must pay each traversal; affine joins do not supply coordinate conversion; causal persistence does not maintain a current selected union automatically; unary coherent algebra supplies no growing-branch merge. Independent-store joins and arbitrary alias/residual scales remain separate.

Evidence and contribution

The audit independently counts mixed coordinates, simulates the literal greedy producer, and tests the cut-congestion inequality and tree-isomorphism control. Python sets, strings and integers are finite semantic oracles, not native instructions. Review 213 records the scope, independent review and publication state.

The contribution is an explicit failure of a proposed transfer between two existing Lab constructions, with a finite-tree charging criterion explaining that failure. The ingredients are elementary prefix-tree counting and the existing mixed-coordinate union analysis. No external priority claim, root admission or new numbered native theorem is made.