R12 Self-Canonicalizing Epoch Retirement Transformer Theory

Protocol: R12-SCERT-THEORY-PREREG-v4

Status: THEORY AND PROSPECTIVE PREREGISTRATION ONLY. This document creates no implementation, corpus, checkpoint, confirmation board, secret, execution plan, or result. It authorizes no code change, CPU capability result, model fit, GPU allocation, H100 job, checkpoint promotion, or scientific claim. H100 execution is explicitly NO-GO until every item in Section 16 is instantiated, hash-bound, and independently accepted in a later executable protocol.

One-sentence hypothesis: a model-authored EOS candidate, a learned COMMIT-versus-HALT decision at a fixed clean probe, position-matched weight-shared reconstruction of the exact latest-state token IDs, and destructive K/V replacement can remove stale-state mediation that post-hoc cache masking cannot remove.

1. Frozen diagnostic basis

These supplied development observations motivate the architecture. They are not results of this protocol and cannot be used as confirmation evidence.

The exact 12-case board has two cases in every width {4,6,8} x operation {add,sub} cell.
Full stale history S0 + generated S1 achieved paired carry-causal exactness 2/12, split 0/4, 2/4, and 0/4 by width.
A fresh source-deleted prompt containing the same latest state achieved 10/12, split 3/4, 4/4, and 3/4. Its nominal target was exact 12/12, counterfactual target 10/12, and output switch 12/12.
Three post-hoc cache arms failed to reproduce the fresh prompt: latest-state K/V only, immutable prefix plus latest-state K/V, and deletion of stale S0 keys while retaining contextualized suffix/latest-state tensors.
The negative is mechanistically expected: K/V for S1 was formed while S1 could attend to S0, so S1 remained a mediator after direct S0 keys were hidden.

The observations identify a stale-context intervention target. They do not show that emitted S1 is valid, that the model can author a boundary, or that retirement improves a complete autonomous trace.

2. Question and strongest admissible claim

The question is:

Given only a frozen instruction scaffold and the model's own latest-state token IDs, can a tied Transformer re-encode that state in a clean epoch, replace the old contextualized cache, and continue until its learned boundary head accepts a model-authored EOS without host semantics, arithmetic, repair, scheduling, or gold tokens?

The strongest eventual positive claim is intentionally narrow and post-dispatch:

On the frozen bounded DWS family and declared runtime, SCERT establishes universal post-dispatch equality under do(P=a/b) conditional on fixed (X1,E,D1,Q_e,I), separately establishes observational independence only if its common-support denominator passes, and improves autonomous exact continuation under a finite hidden-board total-effect comparison.

This is an architecture-plus-runtime claim. It is not a claim about an ordinary uninterrupted-KV Transformer.

2.1 Append-only context versus overwrite semantics

Ordinary causal context is append-only: a later token can add evidence or mask a direct key, but it does not rewrite the contextual representation already built for an earlier token. Algorithmic state machines instead rely on overwrite semantics: after transition S0 -> S1, future execution should consume one current state, not every historical presentation of that state.

Let last(H) be the exact latest-state token string in history H, let P(H) be the mechanically retained prior-source token slot, and define

H ~ H'  iff  last(H) = last(H').
kappa_I(H) = Keep(Enc_theta(R_pm(P(H), token_ids(last(H))),
                            M_clean, p_pm)).

Because M_clean blocks every path from P(H) into every retained position, SCERT maps every admitted history in one ~ class to the single cache representative kappa_I(H). If the latest-state string is causally sufficient for all allowed continuations, this same-string partition approximates the relevant Nerode quotient: histories indistinguishable by every future continuation are represented once rather than as many stale-context aliases. This may reduce history-alias sample complexity by making one state string correspond to one training and inference representation.

That is motivation, not a theorem about learning. The same-string partition can be too coarse when the string omits necessary state and too fine when multiple strings are behaviorally equivalent. This document proves no sample-complexity bound, novelty, general algorithm learning, or SoTA advantage.

3. Exact objects and autonomous boundary machine

Let:

theta       shared Transformer and output weights
G_L, G_R    frozen global instruction tokens before and after the state slot
P_e         exact token IDs of the source state consumed during epoch e
X_e         non-EOS token IDs authored during epoch e
E_e         event that the one effective-logit argmax is EOS ID 0
B_phi       learned linear COMMIT-versus-HALT head
D_e         boundary decision in {COMMIT, HALT}
Q_e         complete non-cache runtime state immediately before dispatch
Enc         the ordinary weight-shared Transformer encoding map
KV_e        the active retained per-layer K/V cache after dispatch

The frozen tokenizer is artifacts/shohin-tok-32k.json, SHA-256 87532df5c121753de3b29194e1f9e3de47986d3f5359548fdf93606773a233d4. There is exactly one vocabulary-logit surface at every token decision. Let h_t be the post-final-norm residual, let U be the tied unembedding, let v0/v1 be the distinct single-character digit IDs bound in Section 9, and let a_M be the frozen motor level for the arm or training stage:

ell_base_t = U h_t
delta_t    = m_psi(h_t)
ell_eff_t  = ell_base_t
ell_eff_t[v0] += a_M * delta_t[0]
ell_eff_t[v1] += a_M * delta_t[1]
y_t        = argmax_lowest_id(ell_eff_t)

a_M=1 in stage-one fitting and every M1 arm; a_M=0 in every M0 arm, which still computes delta_t and discards it. delta_t is cast to the dtype of ell_base_t before the two indexed additions. ell_eff_t, and no pre-motor or second surface, determines the emitted token, event detection, every reported vocabulary margin, and the stage-one vocabulary loss. Thus E_e is exactly the discrete event y_t=0, where token ID 0 is <|endoftext|>; when y_t!=0, that same y_t is appended to X_e. The motor cannot write the EOS coordinate because v0 and v1 are distinct from EOS ID 0, but its two additions can change which token wins against EOS, so event and emission must share this one argmax. A later executable protocol must reject any tokenizer, motor order, dtype cast, tie rule, training loss, or decoder that creates a second predicate. COMMIT is not a host-selected delimiter or a vocabulary token; it is D_e=COMMIT after the model itself creates E_e.

The exact ASCII scaffold bytes are:

<|system|>
SCERT-DWS-v1.
Current state is the only mutable state.
If it is nonterminal, emit exactly one canonical successor state and end the response.
If it is terminal, emit exactly answer=<integer> and end the response.
Emit no explanation.
<|user|>
Current state:
{STATE}
<|assistant|>

G_L ends immediately before {STATE} and G_R begins immediately after it. Their token IDs and SHA-256 must be frozen before any data build.

The boundary head is the minimal affine classifier

B_phi(h) = W_B h + b_B,  W_B in R^(2 x 576), b_B in R^2.
columns = [HALT, COMMIT]; an exact tie selects HALT.

It is evaluated only after E_e. Every primary arm first executes the same clean classification replay defined in Section 4. h_probe is the residual at the fixed final non-padding token of G_R, after all X_e positions, under M_clean. Thus the probe position and input surface are identical across primary arms. D_e=argmax B_phi(h_probe). h_raw, the residual whose ell_eff argmax created E_e, is receipt-only and may feed a separately labeled diagnostic; it never selects a primary-arm action or cache. The head is therefore a separately trained clean-state classifier, not a claimed counterpart of h_raw.

Q_e is not shorthand for phase alone. It is the complete tuple of every non-cache runtime variable capable of changing dispatch or any future call:

Q_e = (phase, commit_count, candidate_count, epoch_token_count,
       total_token_count, replay_slot_cursor, generation_slot_cursor,
       cap_constants, failure_flag, RNG_state_and_cursor,
       deterministic_tie_state, publication_receipt_cursor).

An executable protocol must fail closed if any future-relevant runtime variable is absent from Q_e. The exact source IDs P_e, generated IDs X_e, model cache, and write-only transcript are separate declared objects, not hidden fields in Q_e.

The runtime has ACTIVE and HALTED phases. In ACTIVE:

effective argmax is not EOS: append that same token ID to X_e and update Q_e
event E_e occurs:       freeze exact (P_e,X_e,E_e,Q_e);
                        run the common clean classification replay;
                        compute D_e from h_probe;
                        run the arm's position-matched reconstruction replay
  D_e = COMMIT:         suppress candidate EOS as an internal event;
                        atomically install the retained reconstruction K/V;
                        set P_(e+1) := exact X_e, clear X_e;
                        update Q_(e+1) deterministically and continue from the
                        common final-G_R replay endpoint
  D_e = HALT:           accept candidate EOS, update Q_(e+1), enter HALTED,
                        and return the write-only transcript

The reconstruction replay is executed in every arm even on HALT and then discarded, so action timing and compute do not depend on the arm. Empty, malformed, repeated, or semantically impossible spans are replayed and classified without validation or repair. The caps stored in Q_e permit at most eight COMMIT decisions, nine EOS candidates including final HALT, and 512 generated tokens per epoch. Reaching a cap stops with protocol failure, never success. A cap is not a schedule and does not select a boundary.

For a correct width-w episode, the model must author exactly:

S1 [event E -> COMMIT]
S2 [event E -> COMMIT]
...
Sw [event E -> COMMIT]
answer [event E -> HALT]

EOS alone cannot distinguish a microstep commit from final halt. Always-HALT stops at the first state; always-COMMIT never accepts a final EOS. The learned head, not a host parser, must make the distinction. The host does not know or use w, z, answer syntax, or terminality during scored generation. Commit count, state syntax, answer, and width are parsed only after generation has ended.

4. Position-matched SCERT reconstruction operator

At E_e, the runtime copies IDs without decoding them. Under the frozen tokenizer and exact scaffold bytes above, G_L is exactly 70 token IDs and G_R is exactly 3. The runtime pads P_e and X_e to separate fixed 512-position slots with one frozen dummy token ID and frozen validity bits. The dummy ID is exactly EOS ID 0 with validity false; a masked dummy never creates event E_e. A later executable protocol must bind all 73 scaffold IDs, assert dummy ID 0, and reject a source or authored span longer than 512 before scoring. Define:

P_e*      = fixed 512-position source slot containing exact P_e IDs
X_e*      = fixed 512-position authored-span slot containing exact X_e IDs
R_pm      = G_L || P_e* || X_e* || G_R
p_pm      = 0, 1, ..., 1096
Keep      = retain only valid G_L, X_e, and G_R positions; drop P_e* and pads

The position ranges are exact and immutable:

G_L       [0,70)
P_e*      [70,582)
X_e*      [582,1094)
G_R       [1094,1097); fixed boundary probe at position 1096
generation starts at position 1097 and may occupy at most [1097,1609)

Thus R_pm has exactly 1,097 physical positions. A maximum 512-token generated span ends at position 1,608; its effective EOS argmax creates E_e but is not appended. No claim-bearing call approaches the 2,048-position context limit.

For a cloned one-dispatch mechanistic event, core C0 and C1 receive byte-identical R_pm, validity, positions, weights, and physical shapes. In autonomous evaluation each arm uses the same schema on its own arm-authored event, so later semantic IDs need not match. Both masks are causal and identical except for one declared edge family:

M_clean: valid X_e queries cannot attend valid P_e source positions
M_stale: valid X_e queries can attend valid P_e source positions

In both masks, G_R queries may attend G_L, valid X_e, and earlier G_R positions, but never P_e*; padding is invisible; and all other allowed edges are identical. Consequently the only treatment difference is construction-time X_e <- P_e access. Absolute positions, prompt length, framing, valid tokens, and the final continuation position do not change.

At any arm's own primary event, that arm executes exactly two dense replays:

H_cls       = Enc_theta(R_pm, p_pm, M_clean)
h_probe     = H_cls[fixed final token of G_R]
D_e         = argmax B_phi(h_probe)
H_rec(C1)   = Enc_theta(R_pm, p_pm, M_clean)
H_rec(C0)   = Enc_theta(R_pm, p_pm, M_stale)
KV_rec(Cj)  = Keep(H_rec(Cj).KV)

C1 deliberately re-executes its clean pass rather than reusing H_cls, so the policies have identical forward counts at a given event. On COMMIT, the active arm atomically installs its KV_rec, erases all dropped source/pad K/V and its old active cache, clears X_e, sets its next exact source-ID buffer to its committed X_e, and continues at the position immediately after the final G_R token. The candidate EOS is not installed. On HALT, the active arm discards its KV_rec and accepts its own event. Cloned mechanistic arms share that one event by construction; autonomous arms may author different later events and actions. There is therefore no repeat-EOS versus append-EOS ambiguity in C0.

The replacement is atomic: continuation may observe either the prior complete cache before dispatch or the complete retained reconstruction after it, never a mixture. In C1, P_e* can be computed as isolated dummy work but has no path to any retained representation and is erased at dispatch. A transcript may be retained write-only for later scoring, but it is not model input.

This is endogenous replay and destructive cache replacement. P_e and X_e are exact runtime token buffers; replay content, event timing, and the learned action are model-authored. Buffering, padding, masking, argmax, and atomic swap are fixed mechanical resources. A compact G_L || X_e || G_R replay with reset positions is a separate diagnostic only; it has no primary causal standing.

5. Causal graph with complete runtime state

For one boundary, use:

I        = scaffold, theta, head/motor, slot widths, masks, positions, caps,
           tokenizer, numerical environment, tie rule, and runtime mode
S0       = stale source token IDs loaded into P_1*
U1       = decode randomness used while authoring X1 and event E
X1       = exact authored non-EOS token IDs
E        = model-authored EOS-argmax boundary event
Q_e      = complete pre-dispatch non-cache runtime state
H_cls    = Enc_theta(R_pm, M_clean, p_pm)
D1       = B_phi(H_cls[fixed final G_R token]) in {COMMIT,HALT}
H1_C0    = reconstruction under M_stale
H1_C1    = reconstruction under M_clean
Z1_Cj    = complete post-dispatch state (retained K/V, Q_(e+1), buffers, phase)
UF       = future exogenous random bits
Future   = all later token IDs, events, actions, and stops through HALT or cap

Before conditioning, stale history is allowed to affect what the model authored, when it emitted EOS, and the runtime counters:

S0 ---> X1 <--- U1
 |       |
 +-----> E
 +-----> Q_e
 +-----> H1_C0 ---> Z1_C0 ---> Future

The claim-bearing C1 post-dispatch graph is instead:

(X1,I) ------> H_cls ------> D1
   |             |
   +----------> H1_C1
(X1,E,D1,Q_e,I) ----------> Z1_C1 ----------> Future <--- UF
S0 ---> isolated P_1* --X--> every retained C1 position

--X--> denotes a structurally prohibited edge in M_clean, not an observed zero. This graph supports two different statements: a universal intervention equality for the dispatch function, and an observational conditional-independence corollary only where the conditioning event has support.

6. Structural dispatch invariance and observational corollary

6.1 Universal structural intervention target

Fix I=i, model/motor/head bytes, runtime arm C1, and any syntactically valid fixed values (x,e,d,q). Let a and b be any two source-ID spans of length at most 512, including spans never produced observationally. Assume:

Q_e=q contains every non-cache runtime parent of dispatch and future calls;
R_pm, positions, and M_clean are deterministic, all retained queries are structurally blocked from all valid source-slot keys, and source-slot validity cannot alter a retained mask row;
the action is produced only by the clean classifier at fixed position 1096, never by h_raw;
the atomic dispatch map updates counters, buffers, phase, positions, and RNG cursor only from (x,e,d,q,i) and removes every older cache, residual, source pointer, position offset, and hidden seed path;
numerical kernels satisfy the bound deterministic contract; and
future sampling uses the same law or the same exogenous bits UF.

Then the implementation-level intervention equality is universal over valid source contents:

Z1_C1(do(P_1=a),x,e,d,q;i)
=
Z1_C1(do(P_1=b),x,e,d,q;i).

With common UF, every later token, event, action, cap, and stop is also equal. This is a functional software property. It does not require a or b to have positive probability under the model's observational trace distribution.

Proof

Under M_clean, changing source IDs or source validity in [70,582) cannot alter any retained G_L, X1, or G_R representation. Therefore h_probe, D1, and KV_rec(C1) are equal for fixed (x,e,d,q,i). The post-dispatch buffer and Q_(e+1) are the same deterministic image of that tuple, so Z1_C1 is equal. Induction from equal post-dispatch state and common UF gives equal future execution. QED.

6.2 Observational common-support corollary

The separate observational statement is:

Future _||_ P_e | (X_e,E_e,D_e,Q_e,I), runtime_arm=C1.

It is asserted only for tuples with positive probability under the declared trace distribution. It does not follow from observing off-support do(P) pairs. A hidden observational audit starts with exactly 432 candidate history pairs:

3 edit families x 3 widths x 2 operations x 24 = 432.

The custodian freezes candidates before future decoding. A pair is admitted only when independently generated histories have different P_e but exactly equal (X_e,E_e,D_e,Q_e,I) before looking at any post-dispatch tensor or output. The admitted denominator, rejected case IDs, and rejection reasons are immutable.

An observational independence claim is forbidden unless at least 216/432 pairs are admitted overall and at least 12/24 are admitted in every one of the 18 (edit,width,operation) strata. If that minimum fails, the result is OBSERVATIONAL DENOMINATOR NO-GO; the universal structural intervention theorem and its 384-case mechanistic assay remain separately reportable.

This section says nothing about whether stale source changes the probability or timing of X_e, E_e, D_e, or Q_e, and nothing about the semantic correctness or sufficiency of X_e.

7. Why post-hoc mask-only retirement cannot prove the target

For an S1 token i encoded in full history, one attention layer contains a term of the form:

h_i = F(x_i, sum_j alpha(i,j) V h_j), where j includes S0 positions.
K_i = W_K h_i
V_i = W_V h_i

When any alpha(i,j) on stale position j is nonzero, h_i, K_i, and V_i can depend on S0. Deleting the stale keys only after these values exist removes the direct path S0 -> Future, but leaves:

S0 -> H(S1) -> K/V(S1) -> Future.

The path is open after conditioning on the token IDs of S1, because those IDs do not determine their contextual hidden states.

A scalar counterexample is sufficient. Let a full-history encoder create h(S1)=x+s0 and let the future read only h(S1). After masking the S0 key, Future=x+s0; fixing x=token_ids(S1) does not remove dependence on s0. Therefore post-hoc masks, key deletion, and cache slicing cannot establish the theorem. A construction-time mask that blocks every S1 <- S0 path at every layer could establish it, but that is a new clean encoding operation, not a post-hoc mask over already contextualized K/V.

The same proof applies to boundary control. If B_phi reads h_raw, then S0 -> h_raw -> D_e -> Future remains open even if installed K/V is clean. The theorem-bearing arm must classify the fixed final-G_R probe from the common M_clean classification pass. A raw-residual head is a useful contaminated diagnostic, not SCERT and not a primary arm.

8. Forbidden runtime resources

During every claim-bearing autonomous evaluation, the model/runtime must do none of the following:

decode or parse a DWS field, integer, operation, width, cursor, carry, result, terminal flag, answer, or state validity;
perform arithmetic, an ALU call, solver replay, schedule construction, state transition, state repair, canonical reserialization, verification, retry, or beam/rerank selection;
inject, force, replace, or select any gold state, target token, COMMIT, EOS, answer, head action, or boundary;
choose a cache arm, checkpoint, seed, epoch, stop, or boundary from model output or a score;
after dispatch, retain old epochs through a hidden cache, residual, source pointer, transcript, position offset, random seed, or side channel.

The declared P_e source-ID slot is permitted only during the position-matched reconstruction in Section 4. In C1 it is attention-isolated from every retained position and is erased at dispatch; using it anywhere else is a forbidden hidden source path.

The only online boundary predicate is y_t=EOS on the single ell_eff_t surface in Section 3, followed by the frozen head's two-way argmax on the fixed clean h_probe. The carry motor has no router: in SCERT mode it is evaluated from the current residual at every next-token decision and its declared level controls only the two indexed additions for the tokenizer's single-character digit tokens 0 and 1. It receives no token text, token class, site flag, parsed field, event flag, or position label. A pre-motor EOS check, post-EOS motor call, or separate emission argmax is forbidden.

In particular, the scored arm may not parse z, recognize a state line, inspect answer=, count expected microsteps, or use width to decide COMMIT versus HALT. Those operations are allowed only in explicitly non-autonomous ceilings.

Offline parsing and arithmetic are allowed only after a call has stopped, to construct training labels before fitting, or to construct explicitly labeled causal diagnostics and the non-autonomous host ceiling. None may feed a claim-bearing generation.

9. Parameter and runtime resource dossier

The deployment count uses tied embeddings once.

Component	Unique parameters	Trainable in proposed fit
Parent Shohin GPT	`125,081,664`	`125,081,664`
Epoch-local masks, positions, buffer, swap, FSM	`0`	`0`
Rank-8 carry motor `576->8->2`, with biases	`4,634`	`4,634`
Boundary head `576->2`, with bias	`1,154`	`1,154`
Total	`125,087,452`	`125,087,452`
Strictly addable while total remains `<150,000,000`	`24,912,547`	not allocated

Each evaluated arm loads exactly one boundary head. The true and shuffled heads are alternative 1,154-parameter artifacts and are never resident together; the control replaces the true head rather than adding another head.

The motor count is exact:

576*8 + 8 + 8*2 + 2 = 4,634.
576*2 + 2 = 1,154.

Let v0 and v1 be the frozen tokenizer IDs that each decode to exactly the single ASCII character named by the variable. At every SCERT next-token decision, m_psi(h)=W_up*SiLU(W_down*h+b_down)+b_up is computed and only ell_eff[v0] and ell_eff[v1] may differ from ell_base. The later executable protocol must bind v0 and v1; this document does not confuse them with EOS ID 0 or the tokenizer's unrelated padding ID 1. The protocol's masked dummy remains EOS ID 0 with validity false; tokenizer padding ID 1 is never substituted for it. No caller may expose ell_base as an alternate event, emission, target-loss, or scoring surface.

No learned epoch embedding, reset vector, canonicalizer, position table, parser, verifier, scheduler, motor router, or gate other than the declared boundary head is permitted. Any such tensor creates a new version and parameter ledger.

At BF16, one full active Shohin K/V cache with L real token positions occupies:

30 layers * 2(K,V) * 3 KV heads * 64 head width * L * 2 bytes
= 23,040 * L bytes.

At L=2,048, this is 47,185,920 bytes. SCERT model-visible retained memory is bounded by the current reconstructed prompt, never cumulative epoch history. The runtime also holds one 512-ID source slot, one 512-ID uncommitted span slot, the complete Q_e, and write-only receipts. Actual allocated bytes, transcript bytes, K/V bytes, masks, Q_e bytes, RNG state, model calls, attention-pair counts, and measured FLOPs must be reported per arm; logical bounds are not substitutes for measured resources.

Every model-selected EOS event, including final HALT, spends two full weight-shared re-encodings: the common clean classification pass and the position-matched reconstruction pass. Thus SCERT trades compute for autonomous clean boundary control and destructive context reset. It is not a free cache optimization.

10. Equivalence and internal re-prompting boundary

Endogenous replay

SCERT is closest operationally to internal re-prompting:

ordinary prompt:       host supplies state and starts one decode
fresh host re-prompt:  host selects state IDs and starts another decode
SCERT:                 model supplies state IDs and EOS candidate; its frozen
                       head selects COMMIT or HALT; fixed runtime replays

SCERT does not semantically summarize history. It copies the exact authored IDs into the same frozen state slot and reruns the same weights. Its distinction from fresh host prompting is provenance and control: the model authors replay content, the EOS candidate, and the learned boundary action, while the host performs a fixed mechanical dispatch and reset. That fixed reset remains an essential runtime resource.

Bounded computational equivalence

With finite vocabulary, bounded epoch length, at most eight commits, BF16 K/V, finite parameters, finite runtime state, and a finite RNG state, the set of reachable SCERT configurations is finite. Greedy SCERT is therefore extensionally a deterministic finite-state transducer/Mealy machine. Sampled SCERT is a finite probabilistic transducer. An RNN with sufficient finite state can simulate the same transition system, and a bounded unrolling can simulate it with a fixed feed-forward circuit.

Destructive replay may improve optimization, interference control, and practical memory scaling. It does not create a new computability class. No claim extends to unbounded precision, unbounded state length, unbounded commits, or an asymptotic separation from RNNs, FSTs, recurrent Transformers, or re-prompting.

11. Finite CPU mechanics falsifier

Before any executable neural or H100 protocol may be reviewed, an independent CPU harness must pass all gates below. The harness is a falsifier of mechanics, not evidence of learned capability.

The finite board has exactly:

2 frozen instruction wrappers
x 8 equal-length stale-state edit pairs
x 16 fixed latest-state token spans
= 256 paired cases.

It uses an explicitly initialized two-layer, width-16, two-head toy causal Transformer over a 32-token vocabulary in deterministic float64 CPU execution. Its fixed weights must make the path S0 -> H(S1) -> Future nonzero. Board, weights, masks, positions, and expected outputs must be independently generated and hash-bound in any later implementation.

All of these are noncompensatory:

The one-dispatch harness must clone exact pre-classification (P,X,E,Q,I) before applying an arm. Each clone must execute its own clean classifier and exactly one declared head forward; no probe, logits, or action may be copied between arms. Core C0-true and C1-true receipts must have byte-identical surfaces, validity, positions, weights, probe, action, and physical shapes in 256/256; their reconstruction-mask XOR must equal exactly valid X <- P edges.
Clean C1 retained K/V must be bit-identical, layer by layer, to an independent reference encoding of the same R_pm, positions, M_clean, and Keep projection in 256/256.
At that sole shared dispatch, C0-true and C1-true must have bit-identical h_probe, one-head logits, D, event transition, Q input, and final-G_R endpoint before reconstruction K/V is selected. The assay stops after first post-dispatch ell_base, motor delta, ell_eff, and token.
Under arbitrary do(P=a/b), C1 post-dispatch state, next ell_base, motor delta, ell_eff, and effective-argmax token must be identical in 256/256. C0-true, C0-neutral, and C0-shuffled must have identical open edges; the planted fixture must make only structured true content move output toward its source-implied target in 256/256.
Random-byte or NaN poisoning of every dropped source position and retired cache tensor after swap must leave C1 outputs unchanged in 256/256.
Positions must be fixed and equal across mechanistic arms. Any inherited history offset, compact-position substitution, shifted probe, or changed surface length must fail an exact receipt assertion.
Every ACTIVE/HALTED transition and complete Q_e -> Q_(e+1) map must be exhaustively checked, including non-EOS tokens, empty span, consecutive EOS events, both actions, all caps, and post-HALT tokens. Only the Section 3 effective argmax can create E_e.
The runtime API may accept only exact token IDs, validity, model/cache, complete Q_e, prebound arm ID, and RNG state. Decoded text, parsed fields, gold token, boundary index, or schedule must be impossible by schema.
Every arm must execute exactly one 1,154-parameter head forward per event: true for treatment, shuffled for shuffled control, true-and-discard for fixed or oracle controls, and true-on-raw instead of true-on-clean for the separate raw diagnostic. A two-head receipt must fail.
A two-event autonomous toy must deliberately diverge after its first reconstruction and prove each arm subsequently consumes only its own tokens, E, Q, action, and stop. Any equality-enforcement or cross-arm copy fails.
Always-HALT, always-COMMIT, and fixed-count policies must show exact precomputed finite action traces. No policy may inspect token text.
Motor-off must compute and discard the same delta at every token decision. Between motor-off and motor-on, every ell_eff coordinate except the two frozen single-character digit IDs must be bit-identical. There is no site predicate or alternate event surface.
A finite-state enumerator must reproduce every toy transition and stop state exactly, recording finite-state collapse rather than claiming a new primitive.

One failed item is mechanics NO-GO. Passing opens only review of an executable preregistration; it does not authorize it.

12. Frozen training proposal

The proposed parent is train/sft_digitwise_recurrent_v2_200k_r3/sft_ep1.pt, SHA-256 d79e9df26caecb9801118d1bf68bd7b85381a06b256f23478acffe40a2108459, with 30 layers, width 576, 9 query heads, 3 KV heads, and context 2,048.

Training has exactly 2,048 width-4 add/sub episodes per independent seed:

2 operations x 8 intermediate carry/borrow patterns x 128 = 2,048.

For episode n, lane j in {0,1,2,3,4} has exact current-state token IDs P[n,j], exact target-span IDs X[n,j], and action label A[n,j]. Lanes 0-3 are the four current state -> successor state transitions with A=COMMIT; lane 4 is terminal state -> answer with A=HALT. The data builder rejects any P[n,j] or X[n,j] longer than 512 IDs. It never truncates, reparses, or reserializes a span after tokenization.

12.1 Stage-one base/motor tensor

Every lane is one dense tensor row of exactly 2,048 token IDs, position IDs 0..2047, boolean valid-key bits, a frozen attention mask, and shifted labels. The dummy/padding token is exactly EOS ID 0 with validity false. Valid IDs are left-aligned in their slots. The row is:

positions       content
[0,70)          exact G_L IDs
[70,582)        512 dummy IDs; all invalid (empty retired-source slot)
[582,1094)      P[n,j] IDs, then invalid dummy IDs
[1094,1097)     exact G_R IDs
[1097,1609)     X[n,j] IDs, then invalid dummy IDs
[1609,2048)     invalid dummy IDs

EOS target ID 0 is inserted as one valid input token at position 1097+len(X[n,j]), which ranges from 1097 through 1609; that position replaces the first dummy after X. It exists only for teacher forcing and receives no outgoing loss. The apparent overlap at position 1609 when len(X)=512 is intentional: [1097,1609) contains 512 target IDs and position 1609 contains EOS. Every row remains below context 2,048.

The base-training attention mask is fixed by regions, not content:

valid G_L queries attend causal valid G_L keys;
valid current-state queries in [582,1094) attend all G_L and causal prior valid current-state keys, never [70,582);
G_R queries attend G_L, valid current-state keys, and causal prior G_R, never [70,582);
valid target and teacher-forced EOS queries attend G_L, valid current state, G_R, and causal prior target keys, never [70,582); and
invalid queries attend nothing and invalid keys are visible to no query.

This is the exact clean active-epoch surface used after C1 dispatch: the old source slot is empty, the current state occupies the second 512-position slot, and generation begins at position 1097. It is not the two-state boundary replay surface used to fit the head.

All labels initialize to ignore index -100. Let x=X[n,j] and m=len(x). The only supervised predictor positions and labels are:

labels[1096]       = x[0] if m>0 else EOS_ID_0
labels[1097+k]     = x[k+1] for 0 <= k < m-1
labels[1097+m-1]   = EOS_ID_0 when m>0

Thus each lane contributes exactly m+1 full-vocabulary next-token losses: all target IDs and the model-authored EOS event target. Prompt, dummy, and EOS-input positions have zero loss. Stage one fixes a_M=1 and forms only ell_eff from Section 3. If T_sup is the exact set of supervised predictor positions in the full update, its FP32 objective is

L_stage1 = (sum_(t in T_sup) CE(ell_eff_t.float(), labels[t])
            + 1e-4 * sum_(t in T_sup) logsumexp(ell_eff_t.float())^2)
           / |T_sup|.

There is no per-lane reweighting, pre-motor CE, or separately evaluated EOS loss. The trainer evaluates the displayed loss directly at the listed predictor positions; a library-side second label shift or implicit second model loss is forbidden. The EOS target, digit targets, event predicate, and greedy decoder therefore all train and read the same post-motor effective-logit surface.

The motor site is exact. At every valid model position, including zero-loss prompt positions, h_t is the 576-vector after the final Transformer norm and immediately before the tied unembedding. The base computes ell_base_t; m_psi(h_t) is then evaluated without a router and stage-one a_M=1 creates ell_eff_t exactly as in Section 3. Objective gradients reach the motor only through T_sup; all other positions are outside both CE and z-loss sums. No parsed digit, carry, site, event, or position indicator enters this path.

One logical episode pack is tensor shape [5,2048], not five 768-token lanes. One update contains exactly two packs, shape [2,5,2048], flattened without reordering to [10,2048]. Stage one uses one epoch and all 2,048 packs per seed, for exactly 1,024 updates. Seeds are 2026071814, 2026071815, and 2026071816; none may be selected or dropped. Full model weights and the carry motor are trainable under the token-mean full-vocabulary LM loss above. No boundary-head gradient enters the base or motor.

These are genuine training replicates, not three orderings of one corpus. A domain-separated counter-based PRNG keyed by the declared seed independently determines operand instances within each fixed balance stratum, carry-motor initialization, stage-one pack permutation, stage-two head initialization, and stage-two minibatch permutation. Training rows must be disjoint across seeds by canonical row hash. The parent checkpoint, tokenizer, optimizer hyperparameters, and evaluation boards remain common by design. Any other stochastic source must be either separately domain-keyed by seed and receipted or disabled.

12.2 Stage-two clean boundary-head tensor

Stage two freezes the fitted base and motor. For every one of the 10,240 lanes per seed it constructs one separate dense [2048] replay row:

[0,70)          exact G_L IDs
[70,582)        P[n,j] IDs, then invalid EOS-ID-0 dummies
[582,1094)      X[n,j] IDs, then invalid EOS-ID-0 dummies
[1094,1097)     exact G_R IDs
[1097,2048)     invalid EOS-ID-0 dummies

Positions are exactly 0..2047. Attention is exactly M_clean: valid X queries cannot attend valid P; G_R can attend G_L, valid X, and prior G_R, but never P; invalid positions are invisible. The only extracted feature is the post-final-norm residual at fixed position 1096. This is h_probe.

Stage two extracts exactly 10,240 h_probe rows and fits the 1,154-parameter boundary head by mean two-way CE. It uses AdamW LR 0.01, betas (0.9,0.95), epsilon 1e-8, zero weight decay, batch 512, ten epochs, exactly 200 updates, no warmup, and gradient clip 1.0. The head is then frozen before any autonomous score is opened. No decoded text or syntax-derived feature enters the head.

A separately frozen shuffled-label head starts from byte-identical initialization and sees the same residual rows, minibatch indices, optimizer hyperparameters, update count, and compute. Its numerical parameter updates may differ because its labels differ. Within each five-lane episode its boundary labels are rotated once:

true:     COMMIT, COMMIT, COMMIT, COMMIT, HALT
shuffled: HALT,   COMMIT, COMMIT, COMMIT, COMMIT

The shuffle preserves four COMMIT and one HALT label per episode while breaking the intended terminal relation. It may not share fitted parameters with the true head.

12.3 Exact stage-one optimizer partition and update

The stage-one parameter partition is by exact object identity, not by a future name heuristic. For every block index l in [0,29], Muon owns exactly:

blocks.l.attn.q.weight       [576,576]
blocks.l.attn.k.weight       [192,576]
blocks.l.attn.v.weight       [192,576]
blocks.l.attn.o.weight       [576,576]
blocks.l.mlp.gate.weight     [1536,576]
blocks.l.mlp.up.weight       [1536,576]
blocks.l.mlp.down.weight     [576,1536]

That is 210 tensors and exactly 106,168,320 scalar parameters. AdamW owns exactly the following disjoint identities:

tok.weight, identical by object identity to tied head.weight   18,874,368
blocks.l.n1.w and blocks.l.n2.w for l in [0,29]                    34,560
blocks.l.attn.qn.w and blocks.l.attn.kn.w for l in [0,29]           3,840
norm.w                                                                 576
motor.down.weight, motor.down.bias, motor.up.weight, motor.up.bias   4,634

AdamW therefore owns 126 tensors and 18,917,978 scalar parameters. The union is exactly 125,086,298 unique trainable stage-one parameters. The tied head.weight alias receives no second parameter entry or second update. The boundary head is absent from both stage-one optimizers. Any missing, duplicated, renamed, reshaped, frozen, or additional trainable tensor is optimizer-partition NO-GO rather than an implementation choice.

The parent parameter storage and both optimizer state families are FP32; model forward runs under BF16 autocast, ell_eff is cast to FP32 for the Section 12.1 objective, and there is no gradient scaler or shadow master parameter. At each update, both optimizers are zeroed, one full effective-logit loss is backpropagated, and the single global FP32 L2 norm over the union above is computed. A nonfinite gradient is fatal. If that norm exceeds 1.0, every gradient in both partitions is multiplied once by its exact reciprocal; otherwise no clipping multiplication occurs. Muon steps first and AdamW second. Because their identity sets are disjoint, neither optimizer may read or mutate the other's parameters or state.

There are exactly U=1024 updates indexed u=1..1024. Both base learning rates are multiplied by the same frozen scalar:

s(u) = u/50                                                     for 1 <= u <= 50
s(u) = 0.1 + 0.9*0.5*(1 + cos(pi*(u-50)/(1024-50)))            for 51 <= u <= 1024
lr_muon(u) = 0.001  * s(u)
lr_adam(u) = 0.0002 * s(u)

Muon uses momentum 0.95, Nesterov on, five BF16 Newton-Schulz iterations, coefficients (3.4445,-4.7750,2.0315), normalization epsilon 1e-7, no weight decay, and matrix scale sqrt(max(1,rows/cols)). Its zero-initialized buffer and update are exactly those in train/muon.py, SHA-256 863e79aaaaebb681382f0c88078390b5683ab39be79ac7df60f26d1c04b21762. AdamW uses betas (0.9,0.95), epsilon 1e-8, weight decay 0, bias correction, and amsgrad=False, maximize=False, foreach=False, fused=False, capturable=False, and differentiable=False. Its source is PyTorch 2.10.0 module torch/optim/adamw.py, SHA-256 54299056b7745c162192132bb6028f3387c05ff4203518ff0240058584968312.

For completeness, let g_u be the globally clipped gradient and let all state start at zero. For each Muon matrix, the exact recurrence before the bound Newton-Schulz routine is

b_u       = 0.95*b_(u-1) + g_u
g_nes_u   = g_u + 0.95*b_u
p_u       = p_(u-1) - lr_muon(u)*sqrt(max(1,rows/cols))*NS5(g_nes_u).

For each AdamW tensor, with elementwise square and square root,

m_u       = 0.9*m_(u-1)  + 0.1*g_u
v_u       = 0.95*v_(u-1) + 0.05*(g_u*g_u)
mhat_u    = m_u/(1-0.9^u)
vhat_u    = v_u/(1-0.95^u)
p_u       = p_(u-1) - lr_adam(u)*mhat_u/(sqrt(vhat_u)+1e-8).

Weight decay contributes exactly zero. Every listed identity must have one finite gradient at every update; a missing gradient is fatal rather than a silent optimizer skip. The source hash controls operation ordering, casts, transpose choice, and Newton-Schulz implementation where the equations above do not encode tensor-level evaluation order.

The model source is train/model.py, SHA-256 45fc0dc46ceb0f91d08e3f671cbe9ef202ea212e72d5bba8b77356c3fb0983d4. An executable protocol must byte-match these three sources and reject any functional, fused, foreach, compiled-optimizer, source-fallback, or scheduler substitution. BF16 autocast, FP32 objective, TF32 disabled, pack order, initialization, tokenizer, parent bytes, gradients, clipping coefficient, optimizer state, and every update receipt must be bound before fitting. No early stopping, checkpoint choice, or development-driven hyperparameter change is allowed.

12.4 Frozen boundary-head holdout and global board disjointness

Before any stage-one fit, the complete board registry must be materialized and hash-committed. The boundary-head holdout H_B contains exactly 384 episodes:

3 widths x 2 operations x 8 carry/borrow patterns x 8 = 384 episodes.

For each width w, every episode contributes exactly w clean teacher-forced COMMIT candidate rows and one clean terminal HALT candidate row, each packed exactly as in Section 12.2. The immutable denominator is therefore:

width 4: 128 episodes,  640 rows =  512 COMMIT + 128 HALT
width 6: 128 episodes,  896 rows =  768 COMMIT + 128 HALT
width 8: 128 episodes, 1152 rows = 1024 COMMIT + 128 HALT
total:   384 episodes, 2688 rows = 2304 COMMIT + 384 HALT

Each (width,operation) cell has 64 episodes, 64*w COMMIT rows, and 64 HALT rows. H_B freezes exact canonical episode bytes, token IDs, masks, positions, labels, row order, and denominator before fitting. An external custodian builds and encrypts it, publishes its byte length and SHA-256 commitment, and withholds its decryption material from builders, trainers, operators, and experiment code until all three stage-one checkpoints and all six true/shuffled head artifacts are immutable. Every one of 2,688 rows is scored; missing, duplicate, malformed, or unreadable rows are failures. Revealing any H_B label, residual, prediction, or aggregate before artifact freeze is custody NO-GO. After reveal, no fit, hyperparameter change, checkpoint selection, retry, or replacement board is allowed.

The registry contains the three seed-specific training sets T_14/T_15/T_16, the public 256-case development board D_256, the supplied public 12-case board D_12, H_B, the hidden 384-case mechanistic board H_M, the hidden 768-case autonomous board H_A, and the hidden 432-candidate observational board H_O. Exact disjointness requires zero intersection among all registry entries for both canonical serialized-example SHA-256 and every tokenized row SHA-256.

Semantic disjointness is separately mandatory. Every valid arithmetic episode has canonical key

K_episode = (SCERT-DWS-v1, operation, width, canonical_operand_pair),

where leading zeros are retained, addition sorts the two width-digit operands lexicographically to collapse its commutative alias, and subtraction preserves ordered minuend and subtrahend. Every transition also contributes K_transition=(K_episode,step_index,canonical_current_state, canonical_successor_state). A mechanistic intervention contributes the ordered tuple of operation, width, canonical P_nom, P_cf, fixed X, both frozen source-implied targets, edit family, and edited index. An observational candidate contributes the semantic keys of both source histories. Formatting, tokenization, operand order aliases, or counterfactual presentation cannot create a new key. Every registry row contributes every applicable K_episode and K_transition in addition to its board-specific intervention or history key, so changing key type cannot hide reuse of an underlying arithmetic episode or transition. The semantic-key sets of every pair of registry entries, including the three training seeds, must have empty intersection. H_M and H_A are therefore both exactly and semantically disjoint, not merely differently shuffled views.

The external custodian receives immutable canonical manifests for all training and public boards, generates H_B/H_M/H_A/H_O from separately domain-keyed randomness, rejects collisions before commitment, and publishes a signed zero-intersection certificate containing board counts and the hashes of every private key-set commitment without revealing private cases. Any collision, post-fit resampling, incomplete certificate, or board whose hidden bytes were read by fitting code is package-level NO-GO.

The two stages teach only one-step clean transitions, EOS candidacy, a clean-residual boundary classifier, and terminal answer. Autonomous multi-epoch composition is reserved for evaluation.

13. One-dispatch assay and autonomous total-effect factorial

This section freezes two different future experiments and grants no H100 authority. The first is a matched one-dispatch mechanistic assay. The second is an autonomous total-effect factorial. Their receipts, endpoints, and claims may not be pooled or substituted for one another.

13.1 Matched one-dispatch mechanistic assay

For each assay case and motor level, generation before the first boundary is run once from the common clean initialization in Section 14. That one shared run authors exact (P_0,X_1,E_1,Q_1). The pre-classification state is then cloned byte-for-byte into the mechanistic arms. Each clone independently executes the same clean classification replay and exactly one forward of its declared head; no h_probe, head logits, or action is copied between arms. The receipts must show equal h_probe, true-head logits, and D_1 for the core C0-true and C1-true clones. Those clones therefore have exactly equal P_0, X_1, E_1, Q_1, D_1, weights, motor level, surfaces, positions, validity, and endpoint. Only the reconstruction mask differs: M_stale versus M_clean.

Each clone executes one reconstruction, constructs the complete post-dispatch state, computes the first post-dispatch ell_base, motor delta, ell_eff, and effective-argmax token, and stops. It never generates a second boundary. Equality requirements in the mechanistic assay apply only to the shared initial dispatch. They are not imposed on autonomous rollouts.

Four source-content arms use the same cloned (X_1,E_1,Q_1,D_1):

C1-true: true P_0 IDs with M_clean.
C0-true: the same true P_0 IDs with M_stale.
C0-neutral: M_stale with every valid source ID replaced by tokenizer ID 233, which alone decodes to one ASCII space, while preserving exact source validity, length, positions, and all open edges.
C0-shuffled: M_stale with valid source IDs in exact reverse order, P_rev[k]=P[L-1-k]. It preserves source length, validity, token multiset, positions, and all open edges while destroying serialized order. A source length below two is board-invalid rather than silently left unchanged.

Neutral ID 233 and reversal are committed before model fitting. Neutral IDs are valid attended tokens, not masked padding. C0-true, C0-neutral, and C0-shuffled therefore have identical open attention edges and differ only in source content. This separates structured stale-content mediation from generic extra-key load or attention dilution.

The hidden assay board has exactly 384 paired source interventions:

3 widths x 2 operations x 8 carry/borrow patterns x 8 = 384.

Every case provides same-length P_nom and P_cf, a fixed X_1, and two different source-implied next-token targets frozen by the offline builder before model calls. The true source-directed switch endpoint passes only if C0-true(P_nom) emits the nominal source-implied target, C0-true(P_cf) emits the counterfactual source-implied target, the targets differ, and the outputs switch in that direction. The same endpoint is computed after applying the neutral and shuffled content transforms. Any content transform selected from model output is forbidden.

13.2 Autonomous total-effect factorial

Each frozen seed produces one base/carry checkpoint plus true and shuffled frozen head artifacts before scores open. The autonomous core is:

Factor	Level 0	Level 1
Reconstruction policy	`C0`: use `M_stale` at each arm-authored dispatch	`C1`: use `M_clean` at each arm-authored dispatch
Carry-motor actuation	`M0`: execute the learned delta and set `a_M=0`	`M1`: set `a_M=1` in the single `ell_eff` construction

The four cells C0M0, C0M1, C1M0, and C1M1 start from byte-identical initial token IDs, initial cache, Q_0, true-head artifact, generation cap, and greedy tie rule. The policy first acts at the first model-authored event. After that dispatch, arm-specific caches may produce different tokens. Therefore later P_e, X_e, E_e, Q_e, h_probe, true-head actions, event counts, stop times, and replay contents are explicitly permitted to differ. The factorial estimates the autonomous total effect of repeatedly applying the reconstruction policy, including all downstream token/action mediation. It is not a matched per-dispatch mechanism assay.

Within each arm and at each arm-authored event, the event machine remains fixed: clean classification, exactly one boundary-head forward, one reconstruction under that arm's policy, and atomic dispatch. C0 advances from its own replay endpoint without appending candidate EOS. No arm may borrow another arm's tokens, events, action, Q_e, or stop.

Motor-off is an acute runtime ablation of the same learned parameters. Because stage one co-trains the base and motor, M1-M0 can identify only acute actuation within a motor-conditioned checkpoint, not the effect of adding or training the motor. A training-time motor/no-motor claim requires another preregistration.

13.3 Head and context controls

Every event in every arm executes exactly one affine 576->2 head forward:

treatment and primary-factorial arms load only the true head and use its one forward on h_probe;
the shuffled-head control loads only the shuffled head and uses its one forward on h_probe; it does not execute the true head;
fixed K4/K6/K8, always-HALT, always-COMMIT, target-switch fixed-action, oracle-syntax, and oracle-width/fresh-state controls load and execute only the true head once, discard its action, and apply their declared fixed or oracle action; and
the raw-residual diagnostic is a separate matched arm that executes the true head once on h_raw instead of h_probe; it never executes both.

Thus every arm loads one equal-sized head artifact and performs exactly one head forward per event. The true and shuffled learned-head policies are never resident or executed together. Fixed policies run the complete mixed board and may not be selected by case width. Oracle controls are non-autonomous ceilings and cannot feed, select, or rescue a scored arm.

The post-hoc mask-only negative uses the arm's one declared head action, drops direct stale keys after they have already contextualized X, and executes dummy position-matched reconstruction for compute matching. The compact clean diagnostic uses compact reset positions and is explicitly compound. Fresh host prompting injects oracle states and receives no autonomy credit.

For physical matching, every case in every arm allocates eighteen dense 2,048-position replay tensors, one classification and one reconstruction for each of nine possible events, plus nine 512-position generation budgets. Unused and post-stop work is masked dummy compute. Unpadding, early kernel exit, and variable batch shape are forbidden. Forward counts must match exactly and measured FLOPs within 1%, or the higher-compute control is labeled favorable. Autonomous arms need not have equal semantic tokens after their first divergent dispatch.

13.4 Hidden finite boards and replicate rule

The hidden autonomous board has exactly 768 episodes:

3 widths x 2 operations x 8 carry/borrow patterns x 16 = 768.

H_M and H_A are generated, collision-checked, and hash-committed by the independent custodian under the exact and semantic disjointness contract in Section 12.4. They remain hidden until the Section 16 reveal gate. There is no randomized arm assignment and no assumed exchangeability, so this protocol makes no sign-flip, McNemar, p-value, confidence-interval, or population-frequency claim. It uses exact finite-board thresholds only.

The three seeds remain independent training replicates. For each endpoint and contrast, all three per-seed numerators over the fixed denominator, their minimum, median, and maximum are reported. Every directional and magnitude gate must pass in 3/3; pooling 3N rows or averaging away a failed seed is forbidden. Public development and supplied 12-case results cannot satisfy a hidden-board gate.

The future factorial requires one visible NVIDIA H100 PCIe, batch-one greedy evaluation, BF16 model and effective logits, TF32 off, lowest-token-ID tie break, and complete token, E_e, Q_e, residual, head, surface, validity, mask, position, cache, ell_base, motor-delta, ell_eff, stop, and resource receipts. These requirements do not authorize hardware. No partial score may open before every declared arm and all three seeds are immutable.

14. Evaluation and causal interventions

14.1 Autonomous total-effect evaluation

Every autonomous arm starts from one byte-identical clean initialization tensor:

[0,70)          exact G_L
[70,582)        invalid EOS-ID-0 dummies
[582,1094)      exact S0 IDs, then invalid dummies
[1094,1097)     exact G_R
[1097,2048)     invalid dummies; generation begins at 1097

It uses the stage-one clean active-epoch mask, Q_0=(ACTIVE,0,0,0,0,0,0, fixed_caps,False,fixed_rng_start,fixed_tie_state,0), and the same initial cache. The arm then runs only its declared event machine until its one loaded head accepts a model-selected EOS as HALT or a fixed cap fails. No parser, arithmetic, semantic stop, gold token, retry, or host boundary is available.

After the first dispatch, autonomous arms may and generally will have different tokens, events, runtime state, and actions. Scoring never forces them back onto a matched trace. Full-trace exactness requires all ordered states, the expected number of model-authored COMMIT actions, exact answer, and final model-authored HALT. Missing, malformed, extra, premature-HALT, missed-HALT, or post-terminal spans are failures.

The public development board has 256 width-4 episodes balanced over operation and carry/borrow pattern. The supplied 12-case width-4/6/8 board remains a public cross-width diagnostic. The hidden 768-case autonomous board in Section 13.4 is the only confirmatory autonomous denominator. Width, operation, carry stratum, longest exact prefix, event and commit counts, first failure, state exactness, answer exactness, full-trace exactness, action-sequence exactness, premature-HALT, and missed-HALT are all reported per seed and arm.

14.2 Universal `do(P)` one-dispatch assay

The public 12 cases retain three source interventions each:

E_c:  flip the serialized source carry/borrow bit
E_r:  add one modulo 10 to source written result digit r[0]
E_o:  in order a then b, +1 then -1 modulo 10, use the first active-operand
      edit that changes the frozen source-implied next target

These 36 public pairs and the hidden 384-case assay are structural interventions, not observational matches. They hold exact (X_1,E_1,D_1,Q_1,I) fixed and set the source slot by do(P_0=a) or do(P_0=b), whether or not either joint tuple occurs naturally. They stop after first post-dispatch ell_base, motor delta, ell_eff, and effective-argmax token and cannot feed an autonomous trace.

For C1, every source intervention, including true, counterfactual, neutral, and shuffled content, must yield bit-identical h_probe, head logits/action, retained layerwise K/V, post-dispatch Q_2, next ell_base, motor delta, ell_eff, and effective-argmax token. Each cache must equal an independent reference encoding of the exact R_pm, validity, positions, M_clean, and Keep projection. This tests the universal structural property; no common-support filter is applied.

For C0, true, neutral, and shuffled content use identical M_stale open edges. The scorer reports any-content change, source-directed paired switch, nominal and counterfactual target exactness, and effective-logit-margin movement toward the frozen source-implied target. Directional true-content response, not arbitrary output difference, is required to establish semantic stale mediation rather than generic extra-key dilution.

14.3 Observational common-support audit

The separate 432-candidate hidden audit in Section 6.2 uses naturally generated history pairs. Admission is determined solely from pre-dispatch receipts. Every admitted C1 pair is decoded from the matched dispatch with common future random bits through HALT or cap; complete post-dispatch state and future receipts must be exact. The 216-overall and 12-per-stratum minimum is noncompensatory. Structural do(P) results may not fill an observational denominator.

14.4 Latest-state target-switch interventions

This is a labeled fixed-action structural reconstruction diagnostic, not an autonomous arm. It is applied to every D_12 episode for public sanity and every H_A episode for the fixed hidden denominator. Before fitting, the board custodian freezes for each episode exact P_0, canonical same-length token spans X_nom, X_carry, and X_result, the one-token edited index and replacement ID for each intervention, and canonical full next-span targets Y_nom, Y_carry, and Y_result. X_carry differs from X_nom only by the serialized carry or borrow bit. X_result differs only by r[0] modulo 10. All three spans must have identical token count, positions, validity, and scaffold surface. A missing, multi-token, length-changing, or ambiguous edit makes the fixed case fail; the runtime may not search for another edit.

The arm is exactly TS-C1M1: reconstruction uses M_clean, the carry motor is fixed on with a_M=1 at every vocabulary decision, and the frozen true boundary head is the only loaded head. The nominal arm teacher-forces X_nom on the clean active-epoch surface and evaluates the next-token ell_eff after its last token. That one effective argmax must create nominal event E_1; otherwise all target-switch endpoints for the case fail. The runtime freezes the complete nominal Q_1, executes the nominal arm's one clean classifier and one true-head forward, and records nominal D_1. D_1 must be COMMIT; otherwise the case fails. Exact (P_0,E_1,D_1,Q_1,I), weights, motor level, caps, RNG state, and tie rule are then cloned into the counterfactual arm. Only do(X_1=X_carry) or do(X_1=X_result) differs from the nominal arm.

Three controls are separately frozen and use the same board rows, nominal (E_1,D_1,Q_1), fixed-action rule, head-forward count, generation endpoint, and failure accounting. TS-C0M1 changes only reconstruction to M_stale; TS-C1M0 changes only to a_M=0 while still computing and discarding the motor delta; and TS-post-hoc-M1 uses the Section 13.3 post-hoc mask-only cache. No other target-switch reconstruction policy, motor level, or control may be added after fitting.

Each counterfactual arm independently executes its own clean classification replay and exactly one true-head forward. Its effective EOS receipt must still equal cloned E_1, and its observed head action is recorded. For causal isolation, both arms discard the observed action after that one forward and dispatch the cloned nominal D_1=COMMIT, exactly like a fixed-action control in Section 13.3. If a counterfactual observed head action differs from D_1, the boundary_action_changed count increments and that pair fails every paired target-switch success endpoint. A boundary-action change is never credited as an output switch, target switch, or autonomous success.

Each arm performs its one declared reconstruction or post-hoc operation, installs its resulting retained cache at the common final-G_R endpoint without the candidate EOS, and greedily emits from its declared a_M effective-logit surface until the next effective EOS argmax or the 512-token cap. The scored output Y_hat is the exact non-EOS token sequence; the diagnostic stops before classifying or dispatching that next EOS, so there is no second boundary action. A paired carry target-switch passes only when:

both initial effective EOS receipts equal cloned E_1 and both observed head actions equal cloned D_1=COMMIT;
Y_hat_nom=Y_nom and Y_hat_carry=Y_carry exactly through the next EOS;
Y_nom != Y_carry; and
Y_hat_nom != Y_hat_carry in that frozen target direction.

Full-target exactness, raw output difference, boundary-action change, and paired target switch are separate counts. Counterfactual exactness alone is invalid. The written-result arm uses the same frozen TS-C1M1 procedure and is corroboration only; it cannot rescue failed carry switch. Because E_1, D_1, and Q_1 are nominal structural interventions, none of these arms receives autonomy credit or enters the autonomous total-effect numerator.

14.5 Clean-direct equality and output preservation

At every actual clean head-authored COMMIT, a read-only independent audit call encodes the exact same R_pm, validity bits, p_pm, M_clean, dtype, and weights, then applies the same Keep projection. Every retained layer K/V, next ell_base, motor delta, ell_eff, fixed final-G_R h_probe, boundary-head logits, boundary action, and post-dispatch Q_(e+1) must be bit-identical to those used by C1. The audit result cannot alter decoding.

A frozen 128-prompt non-DWS preservation set is decoded for 128 greedy tokens from both parent and fitted checkpoint with SCERT mode disabled. Token IDs must be exactly equal, with zero SCERT boundary dispatches and zero motor calls. Within the fitted checkpoint, a frozen teacher-forced set of 512 non-carry DWS prefixes is scored with the motor off and on. Every ell_eff coordinate except v0 and v1 must be bit-identical, and effective-argmax token IDs must be unchanged. Carry positions are identified only by the offline scorer after both calls. The boundary head may never alter ell_base, the motor delta, ell_eff, or create an EOS candidate. Any failure is a package-level preservation veto.

15. Decision gates

All denominators include malformed, missing, capped, and non-EOS calls as failures unless a subsection explicitly defines pre-output observational admission. Every seed, width, operation, and frozen stratum is reported; seed or case exclusion is forbidden. All thresholds are finite-board requirements with no p-value interpretation.

15.1 Mechanics, separation, and autonomy vetoes

every CPU mechanics item passes;
the one-dispatch assay validator proves the core clones share exact (P,X,E,Q,D,I) at their sole dispatch and stop after one next-token receipt;
the autonomous validator proves equality is required only at initialization, never forces later tokens/events/state/actions to match, and never transfers a receipt between arms;
every C1 structural source intervention and clean-direct audit is bit-exact;
event detection, emitted token, motor delta, every vocabulary endpoint, and stage-one CE/z-loss all use the one ell_eff surface with no second argmax;
the exact/semantic board-disjointness certificate, 2,688-row H_B custody, and fixed reveal order in Section 12.4 pass before any fitted score opens;
the 210/126 optimizer identity partition, source hashes, state, clipping, schedule, and 1,024 update receipts match Section 12.3 exactly;
no online forbidden resource is called;
exactly one 576->2 head forward occurs per event in every arm under the artifact/action rules of Section 13.3;
the 128-prompt preservation gate passes exactly.

15.2 Structural and observational non-interference gates

For each seed, C1 must be exact on all 384 hidden structural assay cases under true, counterfactual, neutral, and shuffled source contents: 384/384 equal h_probe, head logits/action, retained K/V, post-dispatch state, next ell_base, motor delta, ell_eff, and effective-argmax token. One mismatch is structural theorem implementation NO-GO.

The observational audit must admit at least 216/432 pairs overall and at least 12/24 in each of its 18 strata. Every admitted pair must have exact complete post-dispatch state and future receipts through halt or cap. A smaller denominator is OBSERVATIONAL DENOMINATOR NO-GO; a mismatch is observational independence NO-GO. Neither outcome invalidates a separately passing universal do(P) result.

15.3 Autonomous boundary-policy gate

On the exact 2,688-row H_B from Section 12.4, in every seed the true head must be correct on at least 2554/2688 rows overall. Its noncompensatory (width,operation) minima are 288/320 for each width-4 cell, 404/448 for each width-6 cell, and 519/576 for each width-8 cell. It must also be correct on at least 2074/2304 COMMIT rows and 346/384 HALT rows. Relative to the same seed's shuffled-label head on the identical rows, it must gain at least 404/2688 correct rows overall, 231/2304 within COMMIT, and 39/384 within HALT. These fixed integer thresholds replace rounded percentages; no row can be admitted, excluded, reweighted, or substituted after reveal.

On the hidden autonomous board, C1M1 exact complete boundary-action sequence must be at least 615/768 overall and 205/256 within each width, in all three seeds. It must exceed the shuffled-head sequence count and each single fixed K4/K6/K8 count by at least 154/768 overall and 52/256 per width. No fixed policy may be selected by case width. Always-HALT and always-COMMIT must have zero complete sequence credit.

Oracle-syntax and oracle-width/fresh-state results are reported as host-scheduled ceilings only. They cannot satisfy, replace, or compensate for this gate. Any scored use of parsed z, parsed answer=, expected width, or a host-selected boundary is automatic autonomy NO-GO.

15.4 One-dispatch semantic stale-content gate

For C0-true, source-directed paired switch must be at least 192/384 overall and 64/128 within each width, in all three seeds. Its directional count must exceed both C0-neutral and C0-shuffled by at least 96/384 overall and 32/128 per width. True, neutral, and shuffled arms must have identical source validity and identical open reconstruction-mask edges in every case.

This gate is noncompensatory. If C0 changes under source content but does not move toward the frozen source-implied target, the result is generic content or extra-key sensitivity, not semantic stale mediation. If the directional gaps to neutral and shuffled controls fail, an autonomous C1-C0 difference may be reported only as a reconstruction-policy total effect; it may not be attributed to removal of semantic stale-source mediation.

15.5 Autonomous reconstruction-policy total-effect gate

On the hidden 768-case board, each of these full-trace count differences must be at least 77/768 overall and 13/256 within each width, in all three seeds:

C1M1 - C0M1
C1M0 - C0M0
C1M1 - post-hoc-mask-only-M1

Longest exact prefix and public-board movement are reported but cannot substitute for these exact hidden finite thresholds. Passing establishes an autonomous total effect of the reconstruction policy. Semantic stale-mediation attribution also requires Section 15.4.

15.6 Noncompensatory carry veto

On the public supplied 12 cases, the following remain required development sanity checks but cannot satisfy the hidden gate:

paired carry target-switch at least 9/12 and at least 3/4 per width;
counterfactual full-target exactness at least 9/12 and 3/4 per width;
output switch at least 11/12 and 4/4 per width;
a paired-switch gain of TS-C1M1 over TS-C0M1 of at least 40 percentage points overall and at least 2/4 within every width.

On the fixed 768-case H_A target-switch overlay, TS-C1M1 paired carry switch must be at least 384/768, exceed both TS-C0M1 and TS-post-hoc-M1 by at least 77/768, and be at least 154/384 separately for nominal c=0 and c=1, in all three seeds. Every boundary-action change is already a failed pair under Section 14.4 and is additionally reported by arm and stratum. Failure of any carry gate vetoes a carry-use or integrated-mechanism claim regardless of nominal exactness, answer score, EOS, written-result response, or fresh-host ceiling. These fixed-action diagnostic counts never receive autonomous credit.

15.7 Acute motor-actuation and interaction gate

An acute motor-actuation contribution within the jointly motor-trained checkpoint may be claimed only if autonomous C1M1-C1M0 is at least 39/768 in full-trace count and fixed-action TS-C1M1-TS-C1M0 is at least 77/768 in paired carry-switch count, with no negative full-trace difference in any width, in all three seeds. This does not support a motor-training or added-parameter claim. A positive acute-actuation-by-reconstruction interaction requires, per seed,

(N_C1M1 - N_C0M1) - (N_C1M0 - N_C0M0) >= 39 of 768,

with a nonnegative interaction count within every width. If reconstruction passes but these motor gates fail, the result is reconstruction-policy GO and acute motor actuation NO-GO. If only C1M1 passes, the allowed conclusion is a joint package signal with no component attribution. Fresh-host performance cannot compensate for any autonomous gate.

16. Non-executable custody and determinism checklist

This is a requirements checklist, not evidence that any requirement has been met. Every item is currently unchecked. No CPU capability claim, model fit, factorial, confirmation call, or H100 job is authorized by this document.

Secrets and environment values capable of authenticating services are never printed, committed, copied into manifests, or written to logs. This checklist must be instantiated in a later executable protocol; prose assertions in this theory draft do not satisfy it.

17. Claim boundaries and next decision

Even a complete pass would establish only bounded DWS token-state retirement under this explicit event-driven runtime. It would not establish:

semantic canonicalization, because the runtime copies IDs without knowing whether they are a state;
a proven Nerode quotient or sample-complexity theorem, because sufficiency of the latest-state string is empirical and representation equality alone gives no learning bound;
arithmetic discovery, state repair, planning, schedule learning, source compilation, broad language reasoning, SoTA performance, or general autonomy;
reliable state authorship outside tested widths, values, operations, syntax, commit count, precision, or context length;
ordinary Transformer recurrence, because replay and destructive replacement are essential resources;
a new memory ontology, computational primitive, or separation from internal re-prompting, RNNs, FSTs, recurrent Transformers, or bounded unrolling;
a hidden-set or promotion claim, because this document creates no secret confirmation board and authorizes no run.

Nor would the current motor factorial establish that training with or adding the motor helped. It can establish only acute inference-time actuation within the motor-conditioned checkpoints. A matched training-time motor/no-motor factorial would be a new protocol.

The learned head can establish bounded autonomous boundary selection only if its frozen controls pass. EOS by itself never establishes model-authored retirement: without the head, distinguishing microstep reset from final halt requires a fixed schedule or host interpretation of state/answer syntax, both external resources.

The universal structural theorem can pass while the observational denominator fails or autonomous behavior remains wrong. That means the dispatch implementation blocks the declared source path, but says nothing by itself about naturally matched histories or authored-state sufficiency. Observational independence can be claimed only after its denominator and exactness gates. Autonomous improvement without the one-dispatch semantic-content gate is only a reconstruction-policy total effect, not evidence of semantic stale-source mediation.

The only current decision is NO EXECUTION AUTHORITY and H100 NO-GO. A later executable version may seek authorization only after every Section 16 item is instantiated and independently accepted.