Late keys: metric discovery reduces to versioned finite actions

Assessments 143-144, 8 October 2026. This is a written reduction and a failed-route analysis, not a new unconditional native recognition theorem. The native bounded-intermediate-diversity theorem remains reader 27.

Assessment 145 continuation

The actual metric-history premise is now discharged by a different representation: reader 28. The common action is injective on the occurring masks of untouched rows. A current finite palette interprets stable row selectors, with local population updates for the named row. This avoids chronological suffix queries altogether and includes fixed normalized row degree, paid left composition and late pins. The generic service below remains open; sections 4 and 8 retain their restricted counterexamples. The current palette is additional correlated metadata outside the prefix-only observation contract. The following assessment 143-144 statement and next targets are historical checkpoints, not the current organizing target.

Strongest useful statement

Assessment 144 sharpens the missing service: a cached mask b at cumulative action P needs no chronological checkpoint if b is in image(P). Store a finite witness c with P(c)=b; every later current prefix Q returns the mask as Q(c). For the full copy/reset continuation class this criterion is also necessary for readout from (P,Q,b) alone. A legal width-two split can force a mask outside that image. Section 8 proves this criterion, eliminates compatible checkpoints from the conditional service, and records why the reviewed product/deque mechanisms do not yet supply the remaining access operation.

For fixed K, metric class discovery does not intrinsically require K persistent predecessor dictionaries. It requires the current K-bit membership mask of the named predecessor. Every class update transforms every other predecessor’s mask by a member of a fixed finite copy/reset monoid. Only the named predecessor needs a point override. Consequently a charged persistent suffix-action reader, with the exact contract below, would remove the key-first restriction under normalized right degree one and compatible predecessor/key lengths. It would also support the left factor and late pins, not just right-table maintenance.

The reduction identifies a representation problem rather than granting its solution. Two tempting shortcuts fail: prefix products do not determine suffix products, and fixed-time correction from an opaque old checkpoint plus a current header is impossible in the stated immutable, identity-free interface. The remaining useful budget is the actual spelling length, not constant time after that spelling has ended.

1. Exact copy/reset action with one named exception

Use K slots as in reader 27. Write beta(x) in {0,1}^K for a predecessor x’s membership in current class predicates. Empty slots have bit zero. For each successful right update (v,w), there is a map F with K coordinates, each either an old coordinate or the constant zero, such that

$$\beta'(x)=F(\beta(x))\quad(x\ne v),\qquad \beta'(v)=F(\beta(v))\lor e_j.$$

Here j is w’s resulting class, and e_j has its sole one at j. This includes duplicate edges; their extra OR changes nothing. The maps form a monoid

$$\mathcal C_K=\{0,1,\ldots,K\}^{\{1,\ldots,K\}},\qquad |\mathcal C_K|=(K+1)^K,$$

where coordinate symbol0 means constant zero and symbol i means copy input i. Composition is substitution of these fixed coordinate symbols. It is a finite control operation for fixed K, with no unbounded arithmetic or pointer tests. Only a subset of the monoid may occur on particular legal relation histories.

Construction of F. Start with the identity. An unchanged occupied predicate retains its coordinate. A retired slot is reset to zero. If an existing target splits into a free slot or its singleton class changes in place, the resulting predicate is P_i union {v}; copy old coordinate i into its destination. A new target that creates a new predicate has predicate {v}; reset that destination. A collision with an already occupied class creates no predicate and requires only retirement of the old slot if its population becomes zero. The named-row OR supplies precisely the new membership. Populations, distances and target labels still follow reader 27’s exact metric rules.

Proof. For x different from v, membership in P_i union {v} equals membership in P_i, and membership in {v} is zero. Retired predicates are absent, and all others are unchanged. For x=v, the destination contains v after the edge, while all other coordinates follow the same copies or resets. These facts prove the displayed identities in all cases, including singleton replacement with no free slot, a shared-class split, merging, slot reuse and duplicates.

For each row x, retain its mask b_x immediately after its most recent named update and a checkpoint c_x immediately after that update’s action. Until x is named again, every intervening action treats it as an ordinary, untouched row. If those actions are F_(a+1),…,F_t, its exact current mask is

$$\beta_t(x)=F_t\circ\cdots\circ F_{a+1}(b_x).$$

A first-ever row has the all-zero mask. After resolving an old row, the named point override and a fresh checkpoint restore the invariant. This is a complete semantic replacement for the K membership dictionaries; it is not yet a bounded-cost implementation of suffix evaluation.

2. What a native suffix-action service must actually provide

Fix the original subsequential target normalizer g and length-class span s. Check, from ordinary clauses, that each predecessor v has at most one distinct normalized target key z=g(w), that z is nonempty and in the normalizer’s domain, and that |floor(log2|v|)-floor(log2|z|)|<=s. At each complete right prefix there must be at most K distinct actual predecessor sets among targets of each key. No target-fibre or original-degree bound is imposed. This is the proposed extension of reader 27, with an explicitly checked language condition.

The missing service operates independently for each key. Its header, checkpoints and finite masks are bounded tuples of pointers and finite fields. It must:

1. Start from a fixed empty header. Given a header and one F in C_K, append F and produce a fresh checkpoint in a fixed bounded local batch. Repeated checkpoint creation is counted. No key-sized work is allowed at this late commit point. The call may receive the old checkpoint being replaced and a fixed-size commit context prepared by the resolving job, or a new-row flag. These are charged pointers, not numeric positions or free refreshed handles.
2. Given the current header, an input-built old checkpoint, its cached mask, and paid spelling receipts for the associated v,z, return the exact suffix action on that mask in at most A(|v|+|z|+1) local operations. It must run as a suspendable bounded-rate job. Construction and working allocation have the same charged bound. A repeated right-row job may also prepare the old-checkpoint replacement context for item 1; a read-only left/query job need not retire any checkpoint. No free numeric position, address order, identity test, hidden timestamp arithmetic, advice or previously resolved mask is provided.
3. Preserve old versions and support their own checkpoint continuations using only fixed-degree chronological records, finite labels/control and fixed old-top observation radius. Total allocation is charged, including abandoned work. Checkpoints from one version are interpreted only by a compatible descendant of that version, or by that exact frozen version.
4. Support the advertised bound for arbitrarily many preceding actions, not merely A log(history length). A bound through live checkpoints is useful only with a proved native maintenance and routing procedure. Stale checkpoints referenced by historical configurations cannot be physically invalidated.

These are conditional premises. The Python checker uses full logs and does not satisfy item 2. No service is supplied by calling a mathematical monoid finite.

3. Conditional native construction, including the difficult input order

Conditional transfer. A service satisfying section 2 yields one deterministic native recognizer for each fixed g,K,s of the complete checked Horn language above. Its logical operations and retained allocation are O_(g,K,s,A)(N), for the actual encoded length N. The immediate PEG consequence is for reversal of that language. There is no claim of a free join of independently built stores.

Retain a global row dictionary D(v) of (key spelling, cached mask, checkpoint, length offset), a key dictionary Z(z) of metric counters and action header, and an actual-target dictionary T(w) of current finite slot labels. Inactive slots and missing targets are distinguished explicitly. The g(w) assignment of an actual target is fixed by its name. Global T entries remain coherent with the current header of their own key. No mass target relabeling is required.

Right record: an old predecessor

During actual v bits, open D and collect v’s spelling. At its delimiter an old row supplies its immutable z receipt, cached mask and checkpoint. While the actual w spelling arrives, run these fixed parallel activities:

• traverse actual T(w), suspending its update capsule;
• compute g(w) and compare its emitted bits against a saved z FIFO, requiring exact equality and exhaustion;
• replay the already stored z to open the current Z(z) header;
• once that header is selected, resolve the cached mask using section 2’s job.

These last two operations are sequential but their total cost is O(|v|+|z|). The length condition gives |v|<2^(s+1)|z|. A fixed subsequential transducer has |g(w)|<=B(|w|+1), including bounded initial and terminal output. Thus a sufficiently large fixed number of local steps per actual w character, with a fixed initial and terminal batch, finishes the whole job by w’s delimiter. It does not wait for g(w)’s final symbol before starting: the old row already supplies z. If g(w) disagrees, reject. A malformed short w may cause an irrelevant unfinished job; reject without flushing it. No two accepted records overlap their commits.

At the delimiter, beta(v), the actual target label and the metric header are ready. Compute reader 27’s collision and capacity cases from beta(v) and the counter table. Commit F, cache beta’(v) and the fresh checkpoint in D(v), update T(w), and close the suspended key/target/row capsules. Each payload and nesting depth is fixed. The service’s append bound is essential here.

Right record: a new predecessor

If D(v) is absent, its membership mask is zero in every current predicate. There is no current-set lookup to postpone. During w, stream g(w) into Z and collect its key receipt, while traversing T(w). The current header can arrive at the last actual character. All required counter decisions use the known zero mask. Commit the finite action and fresh checkpoint, and cache beta’(v) in the already open D(v) path. No late predecessor-dictionary insertion is needed. This is the specific advantage of replacing predicate roots with row masks.

The native doubling clocks and finite residual checks from reader 15 verify the predecessor/key length condition as the two names arrive. The normalizer emits only a fixed number of virtual bits per actual character, so clocks, dictionaries and FIFO work expand into fixed local batches. The degree-one condition is exact key equality on every repeated row; a new row installs its first actual key. Any prefix exceeding K rejects immediately and permanently.

Left records: do not hide another late lookup

After the right block freezes, D(v) still holds possibly stale cached masks. A left clause ends immediately after v, so resolving that mask at its delimiter would be an uncharged second pass. Instead use reader 15’s length-window pending representation with deferred mask jobs as its bounded pending payloads.

A source descriptor has one bucket per normalized-key length class. Its committed trie maps keys to K-bit OR masks. Each bucket has at most one pending job (z receipt, v receipt, cached mask, checkpoint), with length offset bounded by s. A job first opens frozen Z(z), resolves its row mask, then inserts that mask at z into the committed trie. The total local cost is O(|v|+|z|+1), hence at most C(2^j+1) for a class-j key. All working paths and suspended local state have fixed width. Installation preserves the bucket’s logical key-to-mask function.

During actual u, select the source descriptor. During actual v, look up frozen D(v) and service the fixed window around v’s evolving length class. The doubling schedule from reader 15 installs the old pending job in every possible destination bucket before v ends. It works for any suspendable job of the stated size bound, not only word insertion: choose its fixed service rate for the larger constant C. An unpromoted speculative job is discarded without changing the original bucket. At the delimiter put D(v)’s one new job in its now-empty bucket. An absent row adds nothing. Close the source capsule in a bounded batch. No evaluation at this late delimiter is assumed.

Late pins: pending work has to be observable

The source pin selects its descriptor. During b, read actual T(b) and stream g(b) into a current/ahead length-bucket reader. For each selected bucket, query the committed key trie and compare the normalized query against its one pending key receipt. Resolve that pending job’s mask in parallel using frozen Z and the service. This does not install the job or visit any other bucket.

At normalized length2^j the current reader has consumed the full query prefix and completed its bucket’s pending-mask resolution. The initial class costs a fixed batch. During the next2^j normalized bits, the ahead reader resolves the class-(j+1) pending mask and replays the saved query prefix while keeping up with new bits. Its total work is O(2^j), including both tasks, so one sufficiently large fixed service rate completes both before promotion. At most two readers and their bounded-width jobs are present. Early termination discards the ahead reader. Empty normalized strings reject according to the checked syntax; a bounded terminal output of g is processed in the fixed terminal batch.

At b’s final delimiter, OR the committed mask with the resolved pending mask only if its key matched exactly. Test the actual target’s slot label, guarded by target existence. Negating that bit gives the Horn SAT answer. This charges all deferred computation to real query symbols and handles a final pending job without EOF work. Old source descriptors retain their own committed roots and pending jobs; every job refers to the same frozen right version used to create it.

The usual simultaneous-record compiler applies only if the suffix service meets its native premise. All spelling receipts, comparisons, clocks, mask jobs, counter stacks, routes, old-storage observations and allocation are included. Fixed K is a single machine parameter, not an input-sized nonuniform family.

4. Why finite prefix summaries and constant-time handles do not close it

Prefix products lose the needed suffix

Already take the two-element monoid {I,Z}, where I preserves a bit and Z resets it to zero. Put a checkpoint after an initial Z. Either append I or append Z. The prefix aggregate at the checkpoint and at the new end is Z in both histories, but the suffix action on a cached one is respectively one or zero. There is no function of the two prefix aggregates alone that gives the desired suffix. Group cancellation is inapplicable. This is a counterexample to that summary scheme, not to other finite-monoid data structures.

Restricted opaque-handle obstruction

Consider a purported generic service for {I,Z} that records arbitrarily many checkpoints in an immutable finite-label graph of fixed outdegree and answers whether a reset occurred strictly after an old checkpoint. A query receives a fixed tuple describing that checkpoint and a fixed tuple for the current header, plus fixed finite control; no ordinary name or variable-length position is supplied. Forbid pointer equality, alias-identity observations, numeric addresses, allocation metadata, timing channels and indirect mutation. Permit all positive and negative finite-label/null tests and arbitrary preprocessing. Suppose every query uses at most q bounded-radius native steps, with fixed q.

Written restricted adaptation. No such service is exact for all histories. This reuses the Lab’s stable-handle unfolding method, specialized to reset-since-checkpoint queries; it is not a new general handle theorem.

Proof. There is a constant H, depending only on q, local radius and fixed batch rules, bounding the depth of any old pointer path reached from the input handle tuples. Fresh nodes only combine already exposed pointers and cannot reveal a previously unexposed old edge in zero cost. Each checkpoint tuple therefore has one of finitely many depth-H unfolding types over the finite labels and null markers, together with its finite cached fields. Because identity/sharing tests are excluded, equal types give indistinguishable query observations even when combined with the same current header. Induction on query steps proves this for adaptive negative tests and fresh allocations as well.

Create checkpoints c_1,c_2,… with one Z strictly between every consecutive pair. Two checkpoints c_i,c_j, i<j, have the same finite type. Stop immediately after creating c_j. With this one current header, querying c_j must report no later reset; querying c_i must report a later reset. Their observable checkpoint types agree, so the bounded query must give the same answer, a contradiction. All checkpoint data was immutable, so stopping here does not change its type.

A crude finite bound is obtained by counting labeled D-ary unfoldings through H for a fixed number of roots; its magnitude is irrelevant. This is not a cell- probe lower bound with free addresses, and not a lower bound for the ordinary- name native Horn language. Name-indexed access to fresh per-row information, nonconstant charged work and stronger identity observations are outside this interface. The argument does not assert that every reset history is realizable by a fixed legal metric relation stream. It rules out a universal opaque-handle shortcut, which was stronger than the required semantic specialization.

5. A finite live-checkpoint quotient and the remaining charged problem

At a fixed current key/version, retain only the most recent checkpoint for each literal predecessor. Let M be the number of such predecessors. Sort these checkpoint positions semantically, and replace the action interval between each consecutive pair by its product in C_K. Discard the prefix before the oldest retained checkpoint. Include the interval to the current end. There are at most M intervals, apart from empty-boundary conventions. Every live row’s suffix action is preserved by associativity. Checkpoints from older persistent versions are interpreted by that version’s own quotient, not by a destructively pruned later one.

This is an exact static quotient, not an online maintenance algorithm. Coalescing gaps after a checkpoint moves, finding an old row’s boundary, appending a new checkpoint at the late delimiter, and retaining all old quotients still need charged implementations. The Python check constructs the quotient with ordinary sorting solely to test the semantic identity.

The normalized length restriction supplies a useful scale. For a key of length h, every predecessor has length less than2^(s+1)h. Hence

$$M < 2^{\,2^{s+1}h+1},\qquad \log_2(M+1)=O_s(h).$$

Thus a native, fully persistent O(log(M+1))-work suffix reader with constant late commits and charged checkpoint routing would fit section 2’s word-length budget. An O(log(number of all actions)) bound need not fit: targets can have unbounded erased prefixes and the history can keep growing while the set of literal predecessors stays small. Nor is a word-RAM bound automatically a native bound: machine-word arithmetic, indexed arrays, time comparison, mutation and amortized carry propagation must each be replaced or charged.

This is the precise next target: a current-version action index bounded by live row checkpoints, supporting constant late checkpoint creation and name-length- paid resolution. It is stronger and more concrete than requesting arbitrary set-intersection receipts. A failure of its generic form still leaves special properties of realizable metric histories available.

6. Failed direct schedules and surviving alternatives

These failures concern the specified schedules. Global length buckets might service work for a key before that key is selected, as reader 15 does for substitution, so the absence of a per-key service window is not a universal backlog lower bound. That alternative was also followed through: deferring an entire metric update leaves a late target-label write, and its actual target name can be arbitrarily longer than its normalized key. A suspended T(w) path cannot be closed against an interveningly changed global target trie. A useful global-bucket repair therefore still needs an exact current target-label overlay and a no-overflow invariant across the two different length scales. No such invariant is proved here. This is retained as an alternative to suffix actions.

A single target growing through arbitrarily many fresh predecessors already keeps intermediate diversity one while accumulating arbitrarily many deferred insertions under the unserviced-key scheme. The later spelling can be short relative to that accumulated history. Conversely the conditional mask construction handles a new row locally because its old mask is known zero. This separates a genuine exploitable invariant from a generic postponement argument.

7. Evidence, controls and continuation

Python checker checks copy/reset composition, all metric update cases against independently reconstructed set membership, last-touch suffix resolution, retained versions, and live-checkpoint interval compression. Interleaved key-local logs also drive deferred finite-mask source queries against a separate relation-product oracle. It also retains the I/Z counterexample and growing pending controls. Its log scans, numeric positions and sorting are deliberately semantic oracles; it supplies no native suffix service or native timing evidence.

The positive controls remain reader 27’s global/key-first theorem, reader 15’s paid pending-window installation and current/ahead query, and the Lab’s strict FIFO/simultaneous-record compilation. Replay slices pay for observed characters; affine-fragment joins do not provide this nonlinear interval query; persistent causal algebra permits retaining the history without granting access to it; unary coherent capsules supply name paths, not a free current-version handle. None of those controls satisfies the missing suffix-action contract merely by having a compositional algebra. Entry 129’s matching/positive-path conclusions remain imported established theorems under their own interface assumptions.

Historical assessment 143 handoff (review 50 is now completed in section 8): compare full primary mechanisms for dynamic finite-monoid products and purely functional sequence access, starting with Amarilli, Jachiet and Paperman, Dynamic Membership for Regular Languages (https://arxiv.org/abs/2102.07728), and Okasaki, Purely Functional Random-Access Lists (FPCA1995), with Kaplan and Tarjan’s real-time catenable deques as a third control if needed. These are identified candidates, not papers already reviewed in assessment 143. Test exact old-top primitives, pointer/word arithmetic, worst-case versus amortized work, late creation, version ancestry, live-checkpoint pruning, and the complete left/query reduction above.

Status: written semantic action reduction; conditional native transfer with an explicit unimplemented premise; exact restricted failures; finite corroboration. No new unconditional native theorem, root admission, formal replay or novelty claim. Publication536 remains the current reader theorem. Scheduled49 completes only with the coordinated handoff; mathematical96/window4/last reassessment92 remain unchanged. Next50 is the dedicated multi-paper review, not another small supporting lemma. All prior SAT/scaffold results and broader final-only-diversity and independent-store frontiers remain open at their recorded scopes.

8. Prefix images, exceptional checkpoints and the reviewed access boundary

Assessment 144. Written supporting arguments, with no novelty or root admission. The two-paper primary-proof comparison is in review 144. Multiplication below is function composition: UP means U after P. This fixes orientation independently of the input reversal used by the native-to-PEG theorem.

8.1 Exact observation criterion

Let A be a finite monoid acting on a finite set X. A checkpoint stores a cached state b and the cumulative prefix P. The current cumulative prefix is Q=UP for an unknown subsequent action U. An exact reader using only (P,Q,b) exists for all continuations if and only if

UP=VP implies U(b)=V(b), for every U,V in A.

Necessity follows by presenting the reader with equal triples. For sufficiency, fix a finite table: for each realizable (P,Q,b), choose any U with UP=Q and return U(b). The implication makes the choice immaterial. This is a finite-control construction for fixed A,X, not a stored-history search. The criterion is about the actual observation U(b), not recovery of the entire action U.

A sufficient condition for every transformation monoid is b in image(P). Choose c with P(c)=b. Then U(b)=UP(c)=Q(c). The pair (P,b) can therefore be replaced by the single finite witness c. For a group action every P is invertible, so every checkpoint has this form; c=P^{-1}(b). Append-only group actions thus have constant local correction despite the harder indexed-substitution problems for some groups. Those dynamic lower bounds do not transfer to this service.

For the monoid C_K of all coordinate copies and zero resets on X={0,1}^K, the image condition is necessary as well as sufficient. Write P as coordinate symbols p_1,…,p_K in {0,…,K}. Its image consists exactly of vectors b satisfying:

• b_i=0 whenever p_i=0;
• b_i=b_j whenever p_i=p_j is nonzero.

These conditions suffice because each distinct nonzero input coordinate may be chosen independently; unused input coordinates are arbitrary. If the first condition fails, let U copy coordinate i to output1 and zero every other output; let V be the all-zero map. Then UP=VP but U(b) differs from V(b). If the second condition fails, use U and V that copy respectively i and j to output1, with all other outputs zero. Again their compositions with P agree and their values at b differ. These are members of C_K, proving necessity for every K>=1.

This strengthens the earlier reset counterexample without asserting that the separating continuations are legal from every Horn prefix. A restricted reachable continuation family can make more triples readable. Current metric counters, slot populations, name receipts and other metadata are also outside the (P,Q,b)-only reader contract. No communication reduction grants those channels.

8.2 A real split crosses the image boundary

Consider K=2 and distinct ordinary names a,v,w0,w1. Insert edges (a,w0), (a,w1), then (v,w1). Before the third edge the two targets share the predicate {a}, in slot 1; slot 2 is empty. Afterwards the predicates are {a} and {a,v}, and the new row v has mask (0,1). Every completed prefix satisfies width two.

The untouched row a has old mask (1,0) and new mask (1,1). Any copy/reset action that gives this update must copy old coordinate1 to both new coordinates: copying coordinate2 or zero would output zero on a. Hence F=(1,1), whose image is the diagonal {00,11}; the override b=01 is outside it. The cumulative action P after this event has image contained in image(F), so b is outside image(P) regardless of the earlier prefix. This conclusion holds for every copy/reset encoding of this update on these two slots, not just the canonical one.

It would be incorrect to claim that every first singleton birth forces such an exception. On an empty slot, all old row bits are zero, and retaining that coordinate rather than resetting it may also be semantically valid. The strict split above avoids that representation-choice issue. It proves failure of a universal image-compatible encoding policy within C_2, not failure of arbitrary native representations or all reachable-state summary schemes.

8.3 Remove compatible checkpoints from the conditional service

Maintain the cumulative action P in each selected current key header, initialized to identity and updated as P’=FP. This costs a fixed table operation for fixed K. After computing the named override b at an update, test membership in image(P’). If compatible, put a finite witness c in the row’s global D(v) record instead of a chronological checkpoint. Otherwise create the exceptional checkpoint required by section 2. A row record has a finite tag distinguishing these two cases.

For a compatible row, every later untouched update has cumulative Q=UP’, so its mask is exactly Q(c). This remains true through arbitrary further rank drops. On its next named update, resolve once and replace the record according to the same test. If the old record was exceptional and becomes compatible, retire that old live cut using the already required paid replacement route. An exceptional row that has not been revisited is not silently reclassified or pruned.

This is an exact refinement of the conditional construction, not a new premise hidden in it. Right-row lookup obtains c from D(v), and the current key header is selected using section 3’s paid key replay. Left pending jobs and current/ahead query readers take the same finite evaluation branch once their selected header is available. No endpoint spelling or routing becomes free. Witness selection, record tagging, prefix composition and compatible-cache birth require constant finite work and allocation. This means one fixed machine for each fixed K,g,s, with its finite tables in control; it is not a uniform constant-cost table construction for growing K or the growing entry 129 alphabet. Initialization, fixed degree/radius, old-top updates, fixed labels/control, actual encoded N, strict final-symbol deadlines and retained versions remain those of sections 2-3. The native language orientation is unchanged; a successful native recognizer would yield a PEG for its reversal.

Consequently the missing service may index only E exceptional live row receipts, with E<=M. The earlier log(M+1)=O(name length) bound also bounds log(E+1). This does not prove small E, constant-time exceptional birth, paid current-version routing, or a native deletion/compaction algorithm. The strict split demonstrates why exceptions cannot simply be omitted. Rank(P) is nonincreasing, but a point override can repeatedly introduce information outside its image; rank drops alone do not bound the number or the age of exceptional receipts.

8.4 What the full action algebra does and does not imply

C_1 is the commutative two-element identity/reset monoid. For every K>=2, C_K is outside SG. On the first two coordinates choose the swap S and reset R(b_1,b_2)=(0,b_2), fixing all additional coordinates. S^omega is identity and S^(omega+1)=S, so the SG equation specializes to SR=RS. On (1,0) these give (0,0) and (0,1), respectively, and are unequal. Thus the generic dynamic word problem on all C_K letters lies in the hard case of the imported classification.

This is a consequence for indexed substitutions on arbitrary monoid words only. The swap need not be an elementary metric event, arbitrary monoid words need not be legal metric histories, and overwrite reductions need not preserve append-only checkpoints. No native lower bound follows. Even generating a hard submonoid from individually realizable events would be insufficient without a context-compatible, resource-preserving encoding of whole update sequences and queries.

8.5 Failed transfers and the next decisive construction

The review closes three proposed shortcuts, with exact reopen gates:

1. Maintaining a total finite product is not an interval reader. A transfer must either satisfy8.1 on the required observations or supply paid boundary access. Global product-preserving compression may change the value of an old interval.
2. A persistent catenable deque joins and exposes its ends; those operations do not give the current location of an arbitrary old cut. Repeated end removal is correct but charges the number of removed actions. Reopen only with a measured structure plus a name-paid current route or an explicit invariant bounding the removable history by the actual name budget.
3. Static live-cut compression has no online route or late insertion schedule. Balanced rebuilding/path copying after a newly discovered key requires work after the charged name has ended. Reopen with worst-case constant exceptional birth, and replacement/deletion prepared during a repeated row’s target window.

The next attack is an immutable index of exceptional live cuts. A repeated row provides time to find and prepare removal of its old cut, coalescing adjacent finite-action intervals. A fresh exceptional row still needs O(1) insertion at the chronological end after late key discovery. Resolution must cost O(|v|+|z|), not O(log of all past actions). Use the reviewed repair-location idea to keep end repair accessible; do not assume it supplies old-cut routing. Test shrinking and growing live sets, repeated splits/merges, long gaps, retained versions and late ordinary-name pins. The global length-bucket/target-overlay alternative in section 6 remains open. So do final-only diversity, unrestricted SAT/scaffold recognition and independently prepared store joins.

Finite corroboration: prefix-image checker exhausts K=1,2,3, independently forms images from bitvectors, groups continuations by equal UP, and compares their observations on b. It also checks the forced width-two split and SG equations. It implements no native suffix service and supplies no timing evidence.