Prefix depth profiles: the missing joint access operation

Assessment 153, 8 October 2026. Written restricted access argument and sustained failed construction, not a new native recognition theorem. This continues the entry 129 checkpoint and reader 35.

Strongest exact statement and payoff

Independent unary fullness profiles do not give a name-linear procedure for updating an arbitrary prefix-dependent profile. Even maximally shared unary lists can force n(n-1)/2 successor traversals to obtain one aligned conjunction from n roots. The roots and final n may be supplied for free in this restricted test. The profiles arise as actual sibling regions of one finite binary row, whose individual width slices have only a linear mixed frontier.

The obstruction concerns the exposed operations, not the amount of information stored. A joint index prepared while right records arrive can escape it. The remaining native target is precisely such an index, including its preparation, version updates, union and late ordinary-name access. This assessment does not advance the mathematical-result counter or claim novelty.

1. What the desired coordinate must compute

For a finite word set X and binary prefix p define

F_X(p,t) = 1 iff every word pz with |z|=t belongs to X.

The empty suffix is included: F_X(p,0) is the terminal bit at p. For t>0,

F_X(p,t) = F_X(p0,t-1) AND F_X(p1,t-1).

These are exact semantic identities. They are not constant-cost operations on unbounded arrays. For a newly inserted word w of length n, let s_d be the sibling of its length-(d+1) prefix. Put g_d=F_X(s_d,n-d-1), for 0<=d<n. If w was absent, its terminal becomes true. The width-n fullness at its ancestor of depth e becomes AND over g_d for e<=d<n. Therefore the newly full ancestors form one suffix of the path. The cutoff is one beyond the deepest false g_d, or zero if none is false. Old already-full flags cannot occur on that missing-word path.

This recovers the common-width cutoff mechanism. The missing operation in the variable-width case is obtaining all these aligned g_d within the actual n name symbols. It is not constructing the cutoff once those bits are available. For a duplicate word, no flags or counts change.

2. A sharp restricted scan bound, including suffix sharing

Fix n>=2 and define t_d=n-d-1. Profile d is a finite unary bit list at coordinates 0,…,n. Its bit at n is always 1, its bit at t_d is z_d, and every other bit is 0. The queried answer is AND of z_0,…,z_(n-1).

Exposed interface. A profile node has a finite bit label and one successor. The only entry points are the n roots. A client may choose a root without cost, keep arbitrary acquired handles, branch adaptively, inspect zero bits and null pointers, and retain old query work. It may only reach an internal node through successor steps from acquired handles. There are no jump pointers, labels summarizing an unbounded suffix, precomputed joint answers or other entry points. Pointer identities, allocation metadata, timing and control history convey no input-dependent information. Identical suffixes may share nodes. The bound is for a fresh exact query, not a warmed query with a cached answer. Initial client control is independent of z; the disclosed n and root order are fixed across all z. No certificate is smuggled through the preparer’s return status or choice of root order. All lists have the same length n+1.

Written restricted proposition. In the all-one z instance, every exact deterministic client must traverse at least

sum_d t_d = n(n-1)/2

successor edges and inspect all n distinguished labels. For fixed-radius, bounded-operation observations, this is Omega(n^2) local work. A sequential walk of each list attains O(n^2), so the bound has the right order.

Proof. If a distinguished bit is not inspected, change just that bit from 1 to 0, keeping all pointers and other labels unchanged. The answer changes and the transcript does not. Hence every distinguished bit must be inspected.

Sharing cannot shorten the required initial paths in the all-one instance. The suffix starting at coordinate k<=t_d has exactly two one bits, with the last at distance n-k and the first at distance t_d-k. Equality of two such suffixes forces their k values equal and then their d values equal. A suffix after a distinguished bit has only one one bit and cannot equal any of these two-one suffixes. Thus initial paths from different roots share no node through their distinguished bits, even in the minimal suffix DAG. No other root is an entry point into one of these initial paths. Each target requires its t_d successor steps. Sum the disjoint required paths.

The label-flip graph remains a valid representation even if it is no longer maximally shared; maximal sharing is permitted, not required as an observable canonicality certificate. The proposition therefore does not use graph-address changes as evidence. A contract requiring canonical graphs plus a separate canonicalization oracle would be a different, additionally charged interface.

The bound deliberately grants n and root selection in advance. Learning the final width only at the endpoint cannot rescue this scan interface. Conversely, it says nothing against preparing a different interface before the query.

3. Realization by ordinary finite rows

Let cube_t be all binary words of length t, including cube_0={empty word}. Take the query word w=0^n and define

X_z = union over 0<=d<n of (0^d 1 cube_n)
      union over d with z_d=1 of (0^d 1 cube_(n-d-1)).

The sibling prefixes 0^d1 are pairwise prefix-incomparable. Their exact fullness profiles are the lists in section 2: a complete residual level n is always present, and residual level t_d is present exactly when z_d=1. There are no other words in a sibling region. No word 0^n is present. Consequently

cube_n is contained in X_z union {0^n} iff every z_d=1.

Each anchor width n+d+1 contains a single complete cylinder, so its exact-width mixed frontier is d+1<=n. The width-n slice has mixed regions only on the zero spine, hence at most n, before or after insertion. There are n+1 distinct occupied widths in the all-one instance. For powers of two n, widths n through 2n-1 occupy one dyadic class and width 2n the next. An intermediate name of length n therefore gives span at most 1. This is a genuine simple-slice test with unbounded width diversity, not a collection of impossible abstract arrays.

All words are explicit ordinary names. The anchor sets contain n2^n words; the width-n part has at most 2^n-1. With one intermediate name of length n, the right Horn encoding has N=Theta(n^22^n) symbols. Profile construction, routing, distinctness and all auxiliary storage must be paid from this input. Its size can pay substantial joint preprocessing. The quadratic fresh scan bound is therefore neither an Omega(N^2) processing bound nor native nonrecognition. Also, root fullness is an internal certification operation in the proposed profile scheme, not by itself the SAT output required of every possible recognizer.

4. Three attempted repairs and their exact dispositions

Independent ancestor cursors. Start a cursor in sibling profile d when that sibling root is encountered. Advance every active cursor on every subsequent target bit. This computes the right diagonal, but its work is the triangular sum above. Fixed parallel lanes cannot service an unbounded number of cursors. The bound still applies if final n is disclosed earlier. Reopen with shared joint access, not merely a different interleaving of the same successor steps.

Delayed Boolean expressions. Allocate symbolic shift/conjunction records for the ancestor recurrence. This retains a small expression without evaluating the aligned labels. In the interface of section 2, forcing the result later must perform the same successor work. A fresh ordinary pin has only its actual name length plus fixed punctuation available. A symbolic root is therefore not an answer receipt. Paid background evaluation, a bounded directly queryable pending form, or a genuine joint index would change this conclusion; those remain open.

Union of complete-level markers. OR of F_X(p,t) and F_Y(p,t) is not generally F_(X union Y)(p,t). Complementary partial coverage is the missing term. More strongly, for any fixed r choose distinct a,b of length n=r+2 sharing their first r bits. Let A=cube_n minus{a}, B=cube_n minus{b}, and C={a}. A and B have the same cardinality and the same fullness profiles at every prefix of depth at most r. Nevertheless A union C is the whole level and B union C is not. Thus adding a fixed prefix layer to scalar level counts does not produce an exact union interface for arbitrary partial slices. This is a semantic insufficiency witness, not a charged lower bound against richer coordinates.

The full family of profiles at all prefixes includes terminal bits and hence determines X. Its insufficiency is operational, not semantic. Treating the pointwise equations as free operations would erase exactly the cost at issue.

5. What would constitute a useful successor

Dependent escape control, already available. The root-level scan in the stress family can be bypassed by reader 35’s distinct-word counter for width n. That counter does not require radiality in order to detect completion of a single level; radiality is the final gate used to justify the later OR union. For X_z the width-n cardinality is sum_d z_d*2^(n-d-1). Its maximum 2^n-1 occurs exactly when all z_d=1. After insertion of the absent word 0^n, the counter signals Full exactly in that case. Actual width-n names pay the counter’s ordinary-name routing and capacity initialization. Anchors occupy other widths. There is no scan of sibling profiles. This is an application of the completed counter, not another positive native theorem or a newly solved family.

This control prevents a false transfer from the scan bound to a construction lower bound. It also identifies what remains: simultaneously prepare analogous exact counters or predicates at the relevant prefixes, not just at the row root, and retain their useful correlations under union. Giving a raw word a width-first directory key would make its prefix path accessible only after its width is known. A two-stage route can determine the width and then replay the word, at linear total work for a single record. That is a credible alternative to quadratic independent profile walks, but no strict schedule is supplied here: the next record can be much shorter, pending words may belong to many widths, and the final query may arrive before replay ends. Replaying after EOF is not allowed. A bounded pending representation with exact direct queries, as in the earlier class-window construction, is the missing dependent test. Merely asserting amortized linear work does not discharge it.

Seek a jointly prepared index that exposes the diagonal sibling observations under path extension and changing endpoint width, without separate unary walks. Charge creation and persistence of that index while the raw right words arrive; show how it updates without an endpoint scan and how its readout handles the union of two partial regions. A positive subclass should retain unbounded width diversity and include an explicit family beyond the three existing criteria. If the index needs a structural gate, discover and check it from input.

The next dedicated primary-proof review is 60. Compare at least two complete primary mechanisms for persistent indexed sequences, shared batched access or worst-case deferred computation, explicitly against this diagonal workload and the partial-coverage union witness. Do not count a literature analogy or an amortized total as the strict deadline construction.

Controls remain unchanged: reader 35’s radial coordinate makes union bitwise OR; reader 34 charges aggregate mixed regions; reader 33 uses fixed width lanes. The common-width cutoff can inspect the relevant sibling coordinate while streaming. Replay slices pay replayed symbols, affine joins use their restricted algebra, and causal or cubical retention does not supply this new readout. Entry 129’s matching/positive-path results keep their stated contracts; this argument derives neither contract for the full native model. The independent store and conditional OMv bounds remain separate. Any eventual native-to-PEG transfer must still reverse the recognized language.

6. Evidence and scope

Python checker uses literal finite word sets to test the sibling realization and cutoff recurrence. A separately built hash-consed unary DAG tests the nonsharing count even with maximal suffix sharing. Label-flip transcripts test the observation adversary. The existing linked counter independently implements the dependent escape control against literal word counts; finite exact-width frontier counts check the realized rows. These finite checks corroborate the general proofs and do not implement a native compiler. The actual-draft audit and seven-surface disposition are in review 153. There is no new imported theorem, root admission, native endpoint or novelty claim here.