# Reasoning Frontier

## Current Diagnosis

The raw 200k checkpoint is not displaying an unmeasured reasoning capability.
Direct, fresh interaction is `1/7` initially, `0/7` after self-review, `1/7`
with a supplied correct intermediate fact, and `0/7` after compact-state reuse.
It produces incorrect arithmetic, non-executing code scaffolds, and repeated
Markdown. Forced-choice likelihood also ranks the correct answer first in only
`1/7` cases. This is a failure to select and execute a reliable action, not
just a benchmark extraction or visible-chain-of-thought problem.

The live model is a 30-layer, 576-wide, 125-135M parameter transformer. Its
pretraining path is healthy but historically dominated by math/code sources.
That is useful for symbols but weak for answer-mode control and natural-language
parsing. The future language-balanced corpus is a required data transition at
a natural handoff, not a speculative fix for the active run.

## Workspace Hypothesis: A Small Reportable Register, Not More Narration

The [global-workspace study](https://transformer-circuits.pub/2026/workspace/index.html)
is relevant to Shohin, but it is not evidence that a 125M model already has a
usable workspace. Its useful operational claim is narrower: deliberate
reasoning is associated with a **small, reportable, selectively used
representation** that can be written once and consumed by multiple downstream
computations. The study also distinguishes this from ordinary automatic
processing and tests it with causal interventions, rather than treating an
eloquent explanation as evidence of thought.

That maps directly onto the current DRS result. DRS v2 gets the first local
state right on 497/500 core episodes yet ends only 275/500 closed loops; it can
compute a local action but does not reliably transport the evolving state. The
original DRS carrier also needlessly makes the model rewrite immutable operand
tapes on every turn. The static-tape recurrent-register (STRR) control removes
that copy burden: the controller re-sends immutable evidence verbatim, while
the model emits only `p,c,r,z`, the compact mutable register. The controller
does not calculate, repair, rank, or choose that register.

STRR is therefore the first workspace-style experiment, not a latent-reasoning
claim. It advances only if all of these are true on held-out tapes, wording,
and paired counterfactuals:

1. **Write:** the model emits the exact next compact register from the fixed
   tape and preceding register.
2. **Maintain:** model-emitted registers, not solver states, survive the full
   closed loop.
3. **Broadcast:** the same terminal register supports distinct readouts
   (final result and indexed-digit queries), rather than merely the response
   template that produced it.
4. **Intervene:** swapping one operand in a paired counterfactual changes the
   resulting model-authored state and final answer in the predicted direction;
   malformed, zeroed, shuffled, or mismatched registers fail on the same
   readouts.
5. **Generalize:** results hold under disjoint values, widths, and natural
   wording. A default-syntax score is not a workspace result.

Only a positive STRR result justifies the next step: a semantic compiler that
maps natural-language facts into this compact register and then tests
state interchange across paraphrases. A negative STRR result would instead
localize the bottleneck below semantic reasoning, in primitive recurrent state
transport itself. We will not imitate the paper's Jacobian lens prematurely;
after a positive behavioral gate, a lightweight late-layer logit-lens trace
can test whether a stable, reportable register has emerged inside the tiny
model. The behavioral causal tests remain decisive.

## Semantic Bootstrap: Learn One Natural-Language State Primitive Before a Broad Mix

The raw 200k operator transcript and the completed V9 decision eliminate an
important ambiguity: the model does not currently turn a two-field natural
language record into a reusable state, and a large broad mix did not repair
that. It is therefore premature to ask it to reason over long contexts or to
judge an elaborate proof. **V10A** was the next independent test: bridge-only
SFT from the immutable raw 200k checkpoint on the admitted semantic-bridge
corpus. It covers only five solver-verified families: product adjustment,
state chains, base conversion, continuation from a verified fact, and repair
of a wrong computation.

V10A is deliberately a *learnability* ablation. A good in-distribution loss or
visible `<think>` block is irrelevant. It earns a second stage only if it
improves both (a) the value/template-disjoint five-family held-out bridge
evaluator and (b) a fresh direct source-drop/reuse interaction that is not
part of the bridge corpus. This separates “the model can imitate a concise
calculation trace” from “the model can form a small semantic object and use it
after the original story is absent.” Only the latter makes semantic capsules,
context compaction, or CWI scientifically defensible.

The bridge evaluator is still only within-family generalization, so V10A also
faces a separately generated, **evaluation-only semantic-composition suite**:
product-to-chain, base-then-adjust, verified-fact-to-chain, repair-to-chain,
and source-dropped named-state updates. Its values, terms, question forms, and
operation compositions are outside bridge training; an independent audit
rejects exact or word-13-gram overlap with the full bridge corpus. Passing the
bridge evaluator while failing this suite is a narrowly formatted curriculum
result, not semantic state competence.

### V10A Outcome: Reject the Family-Trace Hypothesis

The isolated one-epoch V10A checkpoint fit its 200,000 bridge rows (loss
`1.0546 -> 0.0126`) but did not acquire a semantic state primitive. Its
checkpoint-bound 500-case bridge score was **123/500** answers and **121/500**
solver-equation trace contracts: base conversion 35/100, fact continuation
62/100, product adjustment 3/100, state chain 15/100, and trace repair 8/100.
The separate source-dropped cross-family suite was **4/500**, all four in
repair-to-chain; the other four families, including named-state source drop,
were 0/100. The direct seven-case interview improved only to 3/7 initial,
1/7 review, 3/7 supplied-fact use, and 1/7 state reuse. These are learned
family responses, not a reportable state that survives source removal.

V10A therefore blocks the semantic capsule, CWI, KV-anchor, and ISL branches.
No formatting score, low training loss, or apparently explanatory `<think>`
text can reopen those branches without a source-deleted, multi-consumer pass.

### Next Basis: Two-Value Semantic Transport

The right next experiment is smaller than ISL. V10A confounds language-to-state
transport with multiplication, base conversion, and long family traces. The
new **semantic-basis transport** candidate asks only for a natural-language
record to compile to `ledger:P=<integer>;Q=<integer>`, after which the source is
removed. The same model-emitted ledger must support an add-to-P transition and
two independent consumers (`P-Q` and `P+Q`). Train and held-out splits differ
in values, language, field labels, and domains.

This is not an ISL claim and not a context-scaling claim. It must first pass a
closed-loop evaluator that forwards only the model's exact emitted ledger, then
pass paired state swaps, zeroed/mismatched-ledger controls, and held-out source
language. The Stokes CPU builder is only an audited data-admission step; no SFT
may start until this basis evaluator and its counterfactual controls are bound
to the generated artifacts.

### Exact-Carrier Correction: Semantic-Basis V2

The first admitted semantic-basis corpus remains preserved as a data-quality
artifact, but it cannot be used for the causal experiment. Its compile,
reflection, and update completions contained reasoning prose followed by a
ledger line. Any controller that extracts, parses, or reprints that substring
would become an unmeasured semantic component, so a good score would not prove
that the model's own emission is portable.

V2 is a distinct, immutable candidate with only five targets per episode:
`compile -> ledger:P=<int>;Q=<int>`, `reflect ->` the identical exact ledger,
`update ->` the next exact ledger, and two `answer=<int>` consumers. The
consumer prompts receive the updated raw model emission by one literal-string
replacement and have no access to the source description. The 150,000-row
train / 5,000-row held-out build has distinct train/held-out values, labels,
domains, and every phase's wording. It also enforces uniqueness of both source
and post-update ledgers, so no downstream prompt is duplicated accidentally.

The controller rejects any non-full carrier or answer and never calculates,
normalizes, or repairs a model output. The held-out evaluator requires:

1. Correct exact compile and reflection from two source descriptions.
2. A raw compile emission to drive an update, and that raw update emission to
   drive both arithmetic consumers.
3. Two normal episodes to pass before cross-episode interchange is tested;
   the donor's literal model-produced update string is then placed in the
   receiver's source-deleted consumer prompts.
4. A zero-carrier non-recreation control and an evaluator-created P/Q mismatch
   that must produce the counterfactual answers rather than the original
   answers. These controls are explicitly never called model-authored state.

This is the minimum behavioral analogue of a workspace-style claim: reportable
content, multiple downstream readers, and causal swaps. A pass would still be
only a narrow synthetic transport result. It would justify an isolated learning
ablation, not a broad-reasoning or context-scaling conclusion.

The immutable raw-200k MPS smoke is the pre-learning anchor: both direct and
inference-aligned `Question:/Answer:` four-pair probes are **0/8** correct
compile emissions, **0/8** correct reflection emissions, and therefore 0/8
exact reportability or downstream transport. Its raw continuations are generic
pretraining-style prose (for example, "The first step is ..."), not a ledger.
This is a useful negative: the base model does not already implement the
requested output interface, so any later success must be judged against this
fixed checkpoint and must still survive the controls rather than being called
recovered latent reasoning. The queued full H100 baseline uses that same
standard prompt surface, eliminating SFT/evaluation boundary ambiguity.

The full H100 baseline now corroborates that anchor rather than merely being
consistent with it. Read-only run `687792` evaluated 100 deterministic held-out
pairs from `best_step200000.pt` on the standard Q/A surface: **0/200** correct
compile emissions, **0/200** correct reflection emissions, **0/200** exact
reportability matches, **0/200** correct updates, **0/200** normal strict
transports, and **0/100** model-authored interchange, mismatch, and strict
causal pairs. All 100 per-pair raw transcripts are retained in the
hash-verified artifact SHA-256
`e4a96192abc528bad1a8c7ed4e5f275dc5bdb1080a2ac36a4e65a19026a8067e`; they
show source paraphrase, generic explanation, or prompt continuation, not a
single full ledger. This makes the next SFT a clean **learnability** ablation,
not an attempt to recover an unmeasured raw latent skill.

The isolated learnability result closes the broad V2 claim. One epoch from the
same immutable 200k checkpoint reaches **198/200** exact compile emissions,
**200/200** exact reflection emissions, and **198/200** identical carriers on
the full held-out evaluator. Yet it completes only **23/200** state updates and
**6/200** complete update-plus-two-reader episodes; no pair contains two normal
strict episodes, so all **100** model-authored swap, zero, mismatch, and strict
causal outcomes are zero. The full transcript artifact is SHA-256
`b643241ea154b49482627e9c6c2e73d20ad17b64422cf5341c06702c7327505e`.

This is a useful negative rather than a confusing mixed result: the model can
report and reproduce an exact carrier under two independently worded source
prompts, but cannot reliably operate on that carrier once source information
is removed. It is not flexible multi-reader state, and it is not evidence for
a workspace. The completed train-only diagnostic confirms that this is not an
evaluator boundary failure: it reaches **200/200** compile/reflection/equality,
**194/200** updates, **160/200** normal strict transports, **65/100** raw
model-authored swaps, and **48/100** full causal passes, with artifact SHA-256
`b13050b50345834cf0ce861f23facb0c43a3e9753649ee3d0a410001355171ce`.

The present held-out split changes source wording, labels/domains, value range,
and delta range together. The completed factorial *evaluation* matrix therefore
held three factors fixed while changing one: language, P/Q magnitude, or update
delta. It finds **1/100** strict causal passes for language-only, **3/100** for
values-only, and **2/100** for delta-only, versus **48/100** on train-only
episodes. Each condition still compiles and reflects almost perfectly, so this
is not a format or controller failure: it is a three-axis failure of semantic,
numeric, and operator invariance. The first follow-up may target wording
invariance, but no reflection data or context mechanism is justified yet.

### External Workspace Paper: What It Changes

The 2026 global-workspace paper is a useful experimental standard, not a
turnkey recipe for a 125M model. Its central criteria are stronger than
verbalization: a candidate representation must be reportable, deliberately
modulable, used in intermediate computation, flexibly reused by distinct
downstream readers, and selectively necessary for the resulting behavior. V2
was designed as a small behavioral proxy for the reportability, multi-reader,
and intervention portions of that standard. Its failed held-out operation gate
means Shohin does not yet warrant a workspace claim.

The paper's Jacobian lens is a corpus-averaged, per-layer causal readout, not a
logit-lens screenshot. A faithful implementation would need a reproducible
prompt corpus, averaged Jacobian maps, layer/position selection, and a
pre-registered activation intervention. The prior restricted four-layer digit
lens was negative. A full lens build is therefore deferred until a behavioral
primitive passes a source-deleted causal transport gate; otherwise it risks
finding correlations in a model that cannot use the proposed content.

Its counterfactual-reflection result is directly relevant only as a later
ablation: supervise an interrupted reflection continuation, score the original
uninterrupted context with no reflection request, and compare against a
token-budget-matched neutral auxiliary control. It is not evidence that
visible `think` tokens create reasoning, nor evidence that the technique will
transfer from the paper's large model to this one.

### Conditional Direct Counterfactual Reflection: Operator Semantics, Not a Hidden Carrier

The direct-only operator-anchor experiment is the first clean test of whether
the previous COTA failure was caused by paired-answer grammar rather than by
the entire direct trace curriculum. Only if its pre-registered gate preserves
ordinary direct decoding and produces a bounded operator signal may the next
experiment run.

That follow-up is intentionally different from the closed source-dropped
ledger/workspace branches. It keeps the complete natural-language problem in
context and never transports a hidden state. During training only, an external
interruption reverses one named operation and asks for the operation labels,
the state immediately before it, and the exact counterfactual next state. The
original task's answer is *not* a target on that interruption. Normal
evaluation asks only the original direct question, with no reflection request.

The experiment must have two otherwise identical arms:

1. **Numeric reflection:** the interruption target contains the task-derived
   counterfactual state.
2. **Neutral structural control:** it retains the identical operation-label
   and fixed-width reflection surface, but both state fields are zeros and so
   contain no task-derived numeric information.

The comparison therefore asks a falsifiable question: does supervising a
counterfactual numeric consequence improve unreflected direct operation
selection beyond reflection grammar and operation-name exposure alone? A
credible result requires the numeric arm to beat the neutral arm on the frozen
wording/value/full factor suite and direct transcripts, with no response-mode
leakage, arithmetic/base collapse, or RG regression. It would still establish
only a bounded operator-semantics improvement, not general intelligence or a
workspace.

### Conditional Candidate: Paraphrase-Equivariant State Alignment

If the factor matrix confirms that wording transfer, rather than only numeric
extrapolation, is the bottleneck, test a representation-level objective rather
than another larger response-format corpus. Each train episode already provides
two independently worded source prompts (`compile` and `reflect`) with the
same exact latent P/Q state. At the final prompt token, capture a designated
mid-layer residual for each prompt and add a normalized alignment loss between
the two states while retaining the ordinary completion-only next-token loss.

The aim is deliberately narrow: force distinct descriptions of the same facts
to write a common *internal* state before the ledger is emitted. It is neither
a latent-token rollout nor a claim that the aligned vector is a workspace.
The isolated ablation must use the immutable raw-200k checkpoint and compare:

1. CE-only on the identical paired corpus and update budget.
2. CE plus same-state residual alignment.
3. CE plus a length- and batch-matched **different-state** pairing control.

All three retain the same ledger targets. A benefit is credible only if the
same-state arm improves the source-language-only causal gate over both
controls, then retains a measured fraction of that gain under the values-only
and delta-only gates. Diagnostics must report feature cosine similarity for
same-state versus different-state prompts, feature norms/variance to rule out
collapse, ordinary token loss, and every causal control. No reflection or
context-compaction claim can be made from representation alignment alone.

The paired SFT objective is not, by itself, a mechanistic result. The matching
read-only `eval_paraphrase_state_causality.py` therefore uses a full replay at
every decode token and replaces only the answer-boundary residual after the
selected block. This avoids reusing a pre-patch KV cache whose keys would make
the intervention ambiguous. It evaluates identity replacement, same-ledger
compile/reflect exchange, and different-ledger exchange. A viable state result
requires all of the following: identity replacement is neutral; same-ledger
exchange preserves the target ledger; and different-ledger exchange increases
the donor-ledger likelihood or exact report. Even that result establishes only
causal influence on ledger *report*, not flexible downstream use.

The local raw-200k baseline is cleanly negative over four bidirectional
language-only pairs: **0/8** baseline or same-state exact reports, **0/8**
mismatch donor reports, and zero positive donor-vs-target mismatch margins.
Equivalent and distinct prompt-boundary states are almost indistinguishable
at this layer (mean cosine **0.9747** versus **0.9734**); the mean
donor-minus-target mismatch log probability is **-13.50**. Artifact SHA-256:
`ac6f42ffa36e089afa2ab2da1a9b9b0087287393ab54e9cb9728b15d5852af60`.
The earlier one-pair smoke remains preserved as a path check. This small
baseline is still not a high-power estimate; the aligned, CE-only, and
wrong-state models must each receive the same 50-pair audit after their normal
behavioral transfer gate.

That matched matrix is now complete and rejects PSA. CE-only, same-state, and
wrong-state score respectively **1/100**, **2/100**, and **1/100** strict
language-only causal passes. Their full-replay 50-pair activation audits are
all zero on baseline/identity/same exact target reports, mismatch exact donor
reports, and positive mismatch donor margins. Same-state attraction reduces
its own objective but does not beat the deliberately wrong-state control; both
train to cosine about 0.9998. The 2/100 is well within this small test's noise
and has no causal support. Values/delta scoring and contrastive PSA are
therefore not justified. This closes PSA as an ordinary representation-loss
route and leaves NRR as the next causal-bottleneck test.

### Conditional Follow-Up: Contrastive State Geometry

The raw baseline also exposes why positive-pair alignment may be too weak:
same and different states have nearly identical cosine geometry. The trainer
therefore supports an optional symmetric InfoNCE term over a distinct-ledger
batch: compile must identify its own reflect state among the batch, and vice
versa. Unlike positive-only alignment, this simultaneously attracts equivalent
descriptions and repels other ledger states. It logs positive and hardest
negative cosine separately, and it refuses duplicate ledger states in a batch.

This hypothesis is now closed without a contrastive run. The matched controls
showed that an attraction objective can make even deliberately wrong states
nearly identical while leaving causal behavior null. A stronger geometric loss
would only optimize the same unvalidated surrogate. NRR changes the actual
information path instead of adding another similarity term.

### New Hypothesis: Native Residual Relay

The earlier continuous-memory and CPR branches are closed: they added learned
slots or packet machinery, then failed shuffled-source causal controls. The
next experiment must not add a second model around Shohin and call that
reasoning. **Native Residual Relay (NRR)** instead uses one residual the
existing transformer already computes. There are no relay parameters, slots,
state parser, external readout, or source K/V cache in the downstream pass.

For a source description `S`, encode `S` only through a selected layer `L` and
take that layer's final residual `h(S)`. The remaining blocks then process a
fresh sequence `[h(S), event, query, answer]`; source tokens never enter that
suffix computation. This creates a physical information cut: gradients can
teach `h(S)` to be a useful compact state, but the suffix cannot retrieve a
forgotten lexical source through attention. At inference the identical native
two-pass operation is used. The ordinary `GPT.forward` and flagship remain
unchanged.

NRR is deliberately stronger than response-level state SFT. Each synthetic
world supplies independently worded equivalent sources, a counterfactual
source with one changed fact, source-free forward events, inverse-delta
questions, and two distinct readouts. A model passes only when all of these
are measured on held-out language/value/delta regimes:

1. a relay from either equivalent source gives the same correct downstream
   answers;
2. a counterfactual relay changes the answers in the predicted direction;
3. a zero relay and a shuffled-world relay fail materially; and
4. the source text is absent from the suffix by construction, verified by an
   execution-level no-KV/no-source unit test.

The no-parameter relay primitive and its hard-cut test passed only as
infrastructure. Its CPU-only v1 corpus is admitted on shared Stokes/Newton
storage: 30,000 train rows (SHA-256
`bac1e8d041abbfefa892056302a8d78c14abd0d31dd1694e9bc92aefac2fe03c`) and
2,000 held-out rows (`1d8b633713fff41b331e7c2728e9c0aa3ae307a7b99622c526d99d6dc84120f2`),
with zero duplicate prompts and zero exact or word-13-gram cross-split hits.
The 12-update H100 launch canary exercised gradients and serialization from
immutable raw-200k weights; it was not a capability result.

**Closed result, 2026-07-14: NRR v1 is rejected.** The two full isolated
one-epoch arms, `L=13` (`688533`, 7,465 updates, checkpoint md5
`f721645e5b5c38622cf2bc55563957b9`) and `L=19` (`688534`, 7,465 updates,
checkpoint md5 `1616cf2eb21f656e4e781093fb524dfe`), both score **0/500** on
the frozen combined held-out causal evaluation. That is 0 normal, paraphrase,
counterfactual, direct-bypass, and strict-causal answers for both arms.
The relay is not inert: for L19, replacing it with zero or a shuffled relay
changes the emitted answer on 499/500 and 500/500 cases respectively, and a
counterfactual source changes the prediction on 355/500 cases. But it has no
semantic success: it neither preserves the answer across paraphrase nor
updates it correctly under a counterfactual. A L19 in-distribution diagnostic
is also inadequate: only 21/200 normal, 23/200 paraphrase, 13/200
counterfactual, and 2/200 strict-causal cases. Low training loss therefore
represented local token formatting and near-number imitation, not a usable
latent state. The separately admitted language/value/delta factor suite is
retained for methodology but is not worth H100 time after this primary gate.
No continuation or recurrence may be built from this mechanism.

### Conditional Extension: Native Relay Recurrence (Blocked)

A one-step relay is only a compression test. The actual context-scaling
hypothesis is to reuse the transformer tail as a recurrent state transition
without adding an RNN, memory slots, a controller, or a serialization channel:

`h_0 = Encode_L(source)`

`h_(t+1) = Tail_(L+1..N)([h_t, event_t])[-1]`

`answer = Tail_(L+1..N)([h_T, query])`

The recurrent state would be native and every transition would use the same
frozen architecture and source-free hard cut. That hypothesis is now
**blocked, not pending**: NRR v1 scored 0/500 held-out strict causal and 2/200
on the in-distribution diagnostic, far below the advancement gate below.
Implementing recurrence would merely compound an unlearned state channel.
Retain these specifications as a falsification record, but spend no further
training time on native-relay recurrence unless a materially different
one-step state mechanism independently clears the same gate.

For the current one-step depth sweep, "substantial" is pre-registered as at
least **300/500 strict causal** cases on the frozen combined held-out set,
with each of normal, paraphrase, and counterfactual correctness at least
350/500 and each zero/shuffled relay recreating the normal answer at most
25/500. A candidate meeting that bar must still clear the newly separated
language, values, delta, and combined factor sets before recurrence is
implemented. The full-source bypass remains diagnostic only and cannot satisfy
any of these thresholds.

### New Hypothesis: Counterfactual Residual Algebra

NRR showed that a single source residual can influence a suffix without
becoming a semantic state. The next hypothesis therefore does **not** ask for
another answer conditioned on another hidden vector. It asks the model to make
an *intervention* in residual space work across unrelated worlds.

**Counterfactual Residual Algebra (CRA)** exports a short tape of the last
native residuals from a fixed, ordinary source anchor, rather than adding slots
or parameters. Let `Z(x, y)` be that tape for a world with two latent facts.
For three independently rendered sources,

`A = (p, q_a)`, `A' = (p + d, q_a)`, and `B = (r, q_b)`,

the source-free suffix receives only

`Z(B) + Z(A') - Z(A)`

and a question about the unshown target world `(r + d, q_b)`. It must answer
several readouts (field, sum, difference, and later affine readouts). Thus a
successful model cannot merely encode an answer-like number in one residual:
the residual *difference* for a fact change must transfer over a different
background, and the suffix must decode the composed result with all source text
and all source K/V states absent.

This is intentionally an end-to-end causal objective, not a cosine,
clustering, attraction, probe, or text-state loss. The only supervised target
is the answer produced after the residual intervention. It is also distinct
from the failed DRS/CPR/PSA/NRR branches: no string is emitted or parsed as
state; no learned slot, controller, or packet is added; and a wrong residual
algebra operation has a solver-verifiable wrong answer.

The first candidate begins with a small no-carry arithmetic curriculum so the
test isolates semantic composition rather than the raw model's known multi-
digit arithmetic deficit. It must then clear all of the following before any
larger-value, event-transition, or recurrent version exists:

1. at least **300/500** strict compositional-causal cases on a frozen combined
   held-out set;
2. at least **350/500** correct each for normal source renderings,
   independent paraphrases, and a counterfactual `d` substitution;
3. no more than **25/500** answers recreated by a zero or shuffled residual
   tape; and
4. separate language, value, delta, query-family, and two-edit commutativity
   factor evaluations, all constructed before training.

This is a project-specific falsification attempt, not a claim of a new
general technique. If the residual algebra does not pass the first primitive,
it closes with NRR rather than acquiring a recurrence, a public benchmark, or
a post-hoc story.

### Conditional Fallback: Paired Counterfactual Discrimination

Raw-model geometry gives this first CRA arm a specific, falsifiable failure
mode: the residual differences for `+d` and `-d` are almost collinear even
though their answers must diverge. Ordinary one-target CE could therefore
lower loss by making the source-free suffix sensitive to a broad
"there was an edit" template without making the *direction* of that edit
functional.

The conditional **paired CRA** fallback keeps the exact native tape, hard cut,
source corpus, and no-extra-parameter rule. For each episode it decodes both
`Z(B) + Z(A') - Z(A)` and
`Z(B) + Z(A'_{cf}) - Z(A)`. Besides CE for both solver answers, it applies a
per-example margin only at the output distribution:

`NLL(correct | tape) + m < NLL(opposite-counterfactual-answer | tape)`.

This is not an activation-attraction loss and does not assert that residual
vectors should have a particular cosine. It only rejects a model that assigns
the same completion preference to both causal interventions. Each example's
margin is computed independently, so errors cannot cancel across a minibatch.
The fallback can run only after a fully evaluated ordinary CRA rejection. It
must then clear the same behavioral combined and factor gates; improved
training loss or teacher-forced margin alone cannot advance a context or
reasoning claim.

### Conditional Next Mechanism: Counterfactual Chart Closure (C3)

If paired CRA learns the sign of an edit in-distribution but fails the language
or combined factors, the likely defect is deeper than a missing contrastive
answer: a residual difference is still tied to the particular wording that
produced it. The next candidate is therefore **Counterfactual Chart Closure
(C3)**. A *chart* is simply one natural-language rendering of the same small
two-field world; it is not a learned module, an external state carrier, or a
new model parameter.

For a source state `A`, an edit `d`, a donor `B`, and two independently
rendered charts `alpha` and `beta`, C3 trains and evaluates only functional
output constraints such as:

`Z(B^gamma) + [Z((A+d)^alpha) - Z(A^alpha)]`

and

`Z(B^gamma) + [Z((A+d)^beta) - Z(A^beta)]`.

Both source-free tails must answer the same target world `B+d`. Crucially, a
closed cross-chart path must recover the donor answer:

`Z(B^gamma) + [Z((A+d)^alpha) - Z(A^alpha)] + [Z(A^beta) - Z((A+d)^beta)]`.

The model is never rewarded for a residual cosine, a vector norm, a parser
output, or an explanatory string. It is rewarded only when independently
compiled paths cause the correct tail answer, and it is penalized when a
same-shaped but semantically wrong path reaches that answer. This turns
surface-language invariance from a post-hoc probe into a *path-independence*
requirement on the causal operation itself.

C3 is deliberately conditional on a diagnostic paired-CRA outcome, not on
low loss. A C3 corpus may be admitted only if it has disjoint value ranges,
chart vocabularies, question forms, and exact source bundles across splits.
Its minimum behavioral gate is pre-registered before any training: on a
frozen 500-case jointly held-out suite, at least 300 strict cases must get
both independently compiled edit paths and the cross-chart closed path right;
each direct edit path must reach 350/500; and zero, shuffled, chart-mismatched,
or wrong-inverse paths may recreate the correct answer on at most 25/500.
Separate language, values, edit-magnitude, donor-chart, and two-edit
commutation factors remain mandatory. A pass would establish only a
transportable source-free intervention primitive, not general reasoning. A
failure would close residual-algebra work instead of inviting another format
or geometry loss.

### Next Admitted Research Question: Finite-Query Residual Basis (FQRB)

The completed CRA factor matrix changes the question. Its support-matched
value control keeps every answer string in the training vocabulary but remains
at zero strict causal cases, while the delta factor reaches 208/500 strict.
The primary defect is therefore not merely an unseen answer token and not
primarily the sign of an edit: the model does not yet carry a reusable numeric
source state through the residual composition.

**Finite-Query Residual Basis (FQRB)** tests that prerequisite without asking a
small model to emit an unbounded integer. Each source still contains a base
world, an edited base world, and a donor world, and the decoder still receives
only the source-free composition

`Z(donor) + [Z(edited) - Z(base)]`.

Instead of a single direct numeral, independently sampled suffix consumers ask
for one bounded, solver-derived property of the composed target: signed tens
digit, ones digit, sign, parity, or the relation between the two target
fields. The answer alphabet is fixed and fully present in training. For every
episode the normal and counterfactual edits are selected to change that
consumer's answer, so an edit-insensitive tape cannot pass by returning a
constant class.

This is not a parser, an external calculator, a vector-alignment objective, a
new parameter, or a visible trace. It is functional tomography: the same
source-free native state must support several incompatible finite readouts.
The multi-consumer condition matters. A tape that answers `parity` but cannot
also answer `ones` and `relation` has not established a reusable number state;
it has learned a query-specific classifier.

The admitted train split uses signed two-digit source fields and a fixed finite
answer alphabet. Its first held-out split uses unseen full source bundles and
unseen source wording but no unseen answer classes. Exact three-source bundles
and held-out prompt n-grams must remain absent. A later dedicated magnitude
factor, rather than the first combined score, will move source fields to
three-digit values while retaining the same finite output alphabet. Evaluation
will re-use each encoded source triple for all five suffix consumers, then test
normal, paraphrase, counterfactual, zero, whole-group shuffled, and wrong-query
controls.

Before a full arm is submitted, CPU generation and a separate audit must prove
the coverage and split claims. A future one-epoch isolated arm can advance only
if a frozen 500-episode combined evaluation has at least 300 strict episodes,
each consumer is at least 350/500 on its applicable direct path, all five
consumer answers are jointly correct on at least 300 episodes, and zero,
shuffled, or wrong-query tapes recreate a correct answer on at most 25/500.
The same thresholds apply to the answer-support-matched and language factors;
the three-digit magnitude factor is reported separately as the first true
numeric-length generalization test. A pass would show only a bounded causal
numeric basis. It would be a necessary but still insufficient precursor to a
general reasoning claim.

### Conditional FQRB Ablation: Phase-Aligned Anchor Tapes (PAAT)

FQRB source records are ordinary token sequences, so their terminal anchors
can land at different RoPE positions when a signed or multi-digit value changes
tokenization. Residual arithmetic across `base`, `edited`, and `donor` then
adds states from different positional frames, while the tail may decode that
same tape from positions zero onward. That is a concrete mechanism failure
hypothesis, not an explanation after the fact.

**Phase-Aligned Anchor Tapes (PAAT)** is a zero-parameter ablation. It
right-aligns each source into the same fixed zero-embedded positional window,
so all ordinary source tokens and the terminal anchor use a common endpoint.
The source-free suffix then continues from the anchor's true RoPE positions.
The inserted prefix has no token ids, learned vector, semantic content,
attention mask exception, controller, or external computation. It merely makes
the residual coordinates being added commensurate.

PAAT is eligible only if the current FQRB arm fails its combined or
source-tuple gate. Its experiment must preserve the frozen corpus, layer,
tape length, model initialization, batch/update count, optimizer schedule,
and evaluator; `source_window` is the only changed variable and is bound into
the checkpoint metadata. The same combined, core, magnitude, zero, shuffle,
wrong-query, and transcript gates apply. Equal or worse performance rejects
positional misalignment as the limiting explanation. A positive result would
still establish only a bounded phase-consistent latent basis, not a reasoning
system.

### Conditional Next Hypothesis: Ephemeral-Codebook Latent Interrogation (ECLI)

FQRB's five readers are stronger than one fixed numeral head, but they remain
fixed readers. A model could still learn five template-specific classifiers
whose outputs happen to depend on a source tape. **ECLI** adds a late-binding
test before any semantic or reflection claim: for every source world, the
source-free suffix supplies a fresh arbitrary binding table from each of the
thirteen FQRB semantic classes to an opaque code word. The model must return
the code word, never the semantic class directly.

The source triple and native composition remain unchanged:

`Z(donor) + [Z(edited) - Z(base)]`.

All five consumers of a world share one codebook, while every world receives a
different permutation drawn from sixteen ordinary code words. The source is
absent from the binding-table suffix. Thus a successful output has two
separable requirements: recover the correct semantic property from the tape,
then use the *current* query-local table to bind that property to a code word.
The codebook is not a parser or tool: it is literal prompt text, and all
targets are ordinary next-token targets.

The held-out split must make source bundles, wording, and complete codebook
permutations disjoint from training while retaining the same code-word
vocabulary. Every row also has a codebook-swap control: with the identical
source-free tape and question, two semantic entries of the table are swapped,
and the required output must change to the newly bound code. Normal,
paraphrase, counterfactual, zero, whole-group shuffle, wrong-query, and
codebook-swap controls all count in a group-strict score.

ECLI is eligible **only** after FQRB passes its combined held-out and unseen
source-tuple gates. Its frozen 500-world admission threshold is at least 350
correct cases on every consumer for normal, paraphrase, counterfactual, and
codebook-swap paths; at least 300 worlds jointly strict across all five
consumers; and at most 25 zero, shuffled, wrong-query, or codebook-swap
normal-answer recreations. A pass would establish only a bounded,
late-bound latent interrogation primitive: it would be evidence that a query
can modulate how one source-free state is read. It would not establish
open-ended reasoning, language understanding, or a general workspace.

### Conditional Research Direction: Latent Interrogation Cascade (LIC)

The missing ingredient after a late-bound readout is **intermediate use**. A
model can answer arbitrary probes about a source-free tape and still fail to
prepare that state before an ordinary direct answer. **Latent Interrogation
Cascade (LIC)** is a project-specific attempt to bridge that gap without
teaching visible chain-of-thought or giving the evaluator a parser.

LIC has two strictly separated routes over the same solver-generated world:

1. **Interrogation route:** encode the world once, remove it, and answer a
   randomized sequence of late-bound finite probes from the native tape. Probe
   order, binding table, and selected intermediate property vary per world.
2. **Silent-action route:** encode the ordinary source-visible question, append
   a fixed small number of differentiable native latent-rollout states, then
   supervise only the ordinary final answer. No probe text, binding table,
   ledger, or `<think>` target appears on this route.

The proposed training objective couples the routes only through the model's
shared weights. It does not copy a probe answer into the direct prompt, add a
controller, or decode a model-produced state externally. The key comparison is
a compute- and token-matched **neutral-latent control**: it receives the same
number of latent rollouts and direct-answer updates, but its auxiliary suffixes
are source-independent neutral continuations rather than counterfactual
interrogations. If both improve equally, LIC has no evidence of a reasoning
benefit.

LIC is not eligible until ECLI has passed its multi-reader, codebook-swap, and
source-control gate. A future pass requires direct-answer improvement on
unseen source language and unseen query compositions *without* a codebook or
probe prompt at evaluation, exceeding the neutral-latent control, and
remaining sensitive to a pre-registered source-state intervention. That would
be evidence for a small, silent preparatory computation. It would still fall
well short of a claim of open-ended reasoning, and a failure would reject the
interrogation-to-action bridge rather than invite a larger trace corpus.

### Conditional Next Hypothesis: Counterfactual Reflection Route

An exact external carrier, even if it passes V2, would still be an explicit
tool-use skill. The next question is whether a small model can be trained to
*prepare a useful state without being rewarded for printing a reasoning trace
on the ordinary answer path*. This is the project-specific adaptation of the
paper's counterfactual-reflection idea.

For each solver-verified source record, construct two continuations that share
the entire source prefix:

1. **Direct route:** request the final source-visible answer and supervise only
   `answer=<integer>`; no ledger and no `<think>` token is allowed in the
   target.
2. **Interrupted reflection route:** ask what exact portable state the model
   would report if stopped before answering, and supervise only the strict
   `ledger:P=<integer>;Q=<integer>` carrier.

The practical augmentation arm receives both routes. Its control receives only
direct routes, resampled to match supervised answer-token count, updates,
learning-rate schedule, source records, and prompt lengths. That tests whether
reflection improves a direct-answer foundation rather than merely adding more
supervision. A stricter paper-faithful arm starts from that same direct-answer
foundation and then receives **only** reflection-turn loss; a length- and
token-matched neutral auxiliary continuation is its control. Neither arm is
ever asked for a reflection at ordinary evaluation time.

Held-out scoring first asks the direct route only. A reflection benefit is
credible only when it improves unseen-label direct answers **without** emitting
a ledger, beats its token-matched control, and also succeeds when explicitly
interrupted and routed through the exact-carrier transport gate. This creates a
falsifiable route to an internal preparatory representation rather than
equating visible text with thought.

If the reflection model merely improves the interrupted route but not the
ordinary direct route, it is an output-format skill and is rejected. If both
models improve equally, the auxiliary reflection branch has no demonstrated
value. Any later residual/cache intervention must be evaluated against these
behavioral controls; neither a probe nor a logit lens is accepted as a shortcut
to a thinking claim.

The CPU-only substrate in `train/counterfactual_reflection_protocol.py` now
makes this contrast mechanically testable without creating a corpus or
allocating a GPU. It defines a source-visible direct answer, a counterfactual
interrupted reflection whose response is only an exact post-change state, and a
fixed-shape neutral auxiliary continuation that contains no source-specific
numeric task state. A future data builder must prove tokenizer-level target
budget matching before the control is eligible. Its future source-dropped consumers may forward one full model-authored
state by literal replacement but cannot parse, calculate, repair, or choose it.
`train/test_counterfactual_reflection_protocol.py` covers those boundaries.
This is protocol groundwork only; data generation, SFT, and evaluation remain
blocked on a positive exact-carrier causal result. V2's held-out failure leaves
that gate closed.

### Conditional Context Primitive: Causal Residual Count-Sketch (CRCS)

The rejected packet-memory and semantic-ledger routes share a structural
weakness: they ask the small model to serialize a complete state before it has
shown a transferable internal state. **Causal Residual Count-Sketch (CRCS)**
starts from the opposite end. It retains no model-authored text and introduces
no learned memory slot. Instead, each fixed-format event is encoded once to a
native anchor tape, then placed into a fixed number of deterministic signed
residual lanes:

`S[b] = sum_i sign(i,b) * Z(event_i)` for `b = 1..B`.

The event ordinal determines its public, nonsemantic hash lane and sign; the
controller never chooses a fact by meaning, computes an answer, or rewrites a
state. A later source-free query receives the same fixed-width lane tape plus
its ordinary query tokens. Multiple independent lanes make interference a
measurable capacity property rather than an opaque learned-memory claim. The
model must learn to use the query and native lanes to recover one event or
combine two events. The representation, not an external lookup, carries the
content.

CRCS is deliberately more demanding than ordinary retrieval. Its first
solver-derived curriculum would ask late-bound finite questions about one
event, then about a two-event relation, with all original events removed. The
held-out suite must grow from four training events to eight and sixteen events
at the *same* lane budget, change event wording and assignments, and use
disjoint codebook permutations. It must compare the signed multi-lane sketch
to a token/compute-matched flat residual sum; otherwise an apparent gain could
be ordinary extra capacity rather than structured compaction.

The causal controls are required at each length: zero every lane, shuffle
event-to-ordinal assignments, invert a lane's sign pattern, replace a query
with a mismatched event query, and swap exactly one event between paired
histories. A positive result needs a source-free margin over all controls,
per-event and two-event readout, and a non-collapsing length curve at fixed
lane width. It must also report retained residual bytes and prefill/decoding
work. Passing would establish only a bounded, fixed-width native context
sketch, not unbounded memory or general reasoning.

CRCS is not currently admissible. It requires ECLI to establish that a
source-free latent state can be interrogated through a current query and
binding table. That prerequisite prevents a count-sketch failure from being
misread as a hashing problem when the model cannot yet read one latent state.

The CPU-only `pipeline/generate_causal_residual_count_sketch_v1.py` is staged
for that gate, but no CRCS training data or GPU job is authorized yet. It
refuses any parent assessment other than
`bounded_ecli_late_binding_candidate`, then constructs 12,000 four-event
training histories and 500 held-out histories of eight or sixteen events.
Each history has five consumer questions, a fresh opaque codebook, a
counterfactual event-edit answer, and a same-history codebook-swap answer.
The builder rejects non-changing interventions and records zero exact-history,
codebook, and semantic 13-gram train/held-out overlap before it writes data.
`train/test_generate_causal_residual_count_sketch_v1.py` fixes those
admission and split-audit conditions. This is reproducible curriculum
groundwork, not evidence for CRCS or a claim that the model can reason.
`pipeline/watch_ecli_crcs_admission.sh` is the corresponding one-shot
CPU-only continuation: it may build that audited corpus only after the exact
ECLI assessment is present and positive. It never submits a CRCS training job;
any learned context claim remains separately gated on a later model result.

### Conditional Direct-Transfer Test: Counterfactual Workspace Reflection (CWR)

The raw 200k transcript audit shows that Shohin has neither a dependable
visible scratchpad nor a useful reportable intermediate state. The FQRB/ECLI
branch tests whether a narrow native state can exist without those behaviors.
Only if both stages pass, the next question is whether that state can change
ordinary, source-visible reasoning rather than merely answer an artificial
suffix. **Counterfactual Workspace Reflection (CWR)** is a narrow test of
that transfer.

For a frozen FQRB source triple and ordinary direct question, CWR appends a
counterfactual interruption, such as asking what five semantic facts should
be held in mind before answering. Training computes loss only on the
interruption's reflection, which must name the complete donor-after-edit
state. It never computes loss on the direct answer. At evaluation, the
interruption is absent: the model receives the ordinary source-visible
question and must give the answer directly. A result can therefore not be
explained by having trained that answer completion in the target context.

The arm must use held-out source bundles, wording, query templates, and
counterfactual source edits. It requires a direct answer change under the
edited source, failure under whole-source shuffle or source zeroing, and a
matched placebo-reflection arm whose reflection describes a different world.
It additionally reports a reflection-probed held-out score, but that score is
diagnostic only: the primary endpoint is a source-visible direct answer with
no reflection instruction. The same checkpoint must improve the existing
seven-task transcript audit without a reflection prompt before it can be
called a general capability gain.

CWR is intentionally not a generic chain-of-thought or answer-distillation
recipe. The prediction is mechanistic: if a reportable latent basis exists,
supervising its *future counterfactual report* should make those concepts
available while the preceding direct answer is formed. If FQRB or ECLI fails,
there is no evidence that the model owns such a carrier and CWR remains
blocked rather than becoming another ungrounded SFT run.

### Conditional Context Mechanism: Reversible Semantic Checkpoints

Only after exact transport and the reflection control have a positive causal
result should the project test bounded-context scaling. The candidate is a
**reversible semantic checkpoint**: after a fixed number of events, the model
authors one bounded ledger plus two independently checkable readouts. The old
history is discarded, the ledger is used as the sole prefix for the next
window, and a later query must recover the same state across two consumers.

The checkpoint is not trusted because it is short. At every reset the evaluator
must test a model-authored checkpoint swap between two histories, a zero
checkpoint, a P/Q mismatch, and a replay from the original history. It must
also account for total source tokens, checkpoint tokens, mutable tokens,
prefill work, retained KV bytes, and task accuracy as context length increases.
The mechanism earns a context-scaling claim only if it maintains causal state
utility after resets at a fixed prompt budget; it is otherwise just lossy
summarization.

### Conditional Next Primitive: Interchangeable Semantic Ledger

If V10A learns its five families but fails the cross-family composition suite,
the diagnosis is not simply "needs more examples." Its current traces are
family-specific prose: a multiplication trace, a place-value trace, and a
repair trace have no enforced shared object that a later operation must consume.
That allows separate local programs without an interchangeable semantic state.

The proposed **Interchangeable Semantic Ledger (ISL)** is a deliberately small,
token-native state interface that a model must author and then use. A single
ordinary-language record is compiled to a canonical ledger containing named
values, operation-ready values, and immutable identity fields. The source
record is then absent. A second prompt can ask a distinct consumer to update
the ledger, answer a different query about it, or evaluate a counterfactual.
The controller only forwards exact model-emitted text; it never normalizes a
value, selects a field, or performs an operation.

The requirement is *interchangeability*, not ledger formatting:

1. Multiple unrelated source descriptions must compile to the same typed
   ledger when they denote the same state.
2. The same model-authored ledger must support at least two disjoint consumers
   such as an arithmetic update and an indexed/value query.
3. A paired counterfactual ledger swap must change each consumer's output in
   the solver-predicted direction; zeroed, mismatched, syntax-only, and
   label-permuted controls must fail on the same consumers.
4. Evaluation independently holds out values, source language, field names,
   downstream operation combinations, and multi-step lengths. No exact ledger
   syntax is sufficient without the causal swap result.

V10A failed its own bridge holdout and failed composition, so ISL is explicitly
held. A richer ledger would only add a template before the model has shown that
it can transport even two simple semantic values. ISL can become a controlled
ablation only after the two-value basis passes closed-loop source deletion,
multi-consumer use, and paired counterfactual controls.

If ISL later passes source-deleted, multi-consumer, and counterfactual gates,
the ledger becomes the only admissible input to a context-scaling experiment.
Its exact tokens can be held as a KV anchor, and periodic re-anchoring must be
model-authored and pass the same swap/zero controls. That would measure a real
bounded state-compression mechanism without claiming an extended context window
or allowing an external summarizer to do the reasoning.

### Post-Bridge Semantic Capsule Gate

The existing semantic-capsule corpus is not another raw capability test. Raw
and broad V9 both score zero because neither can initially form a valid capsule;
those controls reject a claim that ordinary pretraining or generic reasoning
formatting already supplies context compression. The corpus remains valuable as
the next **serial** mechanism test after a semantic primitive has been taught.

`sft_semantic_capsule_v11a.sbatch` therefore refuses to start from raw weights.
It requires a V10A checkpoint together with its full 500-case bridge result and
full 500-case cross-family composition result, each bound to that exact
checkpoint and its immutable evaluation data. Admission requires at least
250/500 bridge answers, 200 solver-derived intermediate-equation contracts, at
least 25 such contracts in every bridge family, at least 40 bridge answers in
every family, at least 50/500 cross-family answers, and at least five
composition answers in every family. These are deliberately stronger than
the rejected V9 signal and stop the capsule corpus from laundering a narrow
template result into a context-scaling claim.

Only then does one isolated capsule epoch teach source-deleted write, update,
repair, and readout actions. The SFT is completion-bound to the exact
controller prompt carried in every row; it does not add a second generic
`Question:/Answer:` wrapper. Its held-out 4/8/12-step controller evaluation
uses model-generated capsules only. CBC follows only if this result is nonzero:
the capsule protocol measures persistence across resets, while CBC's paired
counterfactual compiler measures whether a resulting state is causally
interchangeable across worlds. Neither result alone establishes broad reasoning.

### Conditional Engineering Substrate: Causal KV Anchors

The normal cache is a useful engineering mechanism but **not** a context
compression result. Once a model has authored a discrete semantic anchor, its
exact tokens can be prefetched once and their KV cache retained while later
events and model-authored state updates are appended. This eliminates repeated
prompt transmission and repeated prefix projection, but it still has a linear
attention-cache footprint and does not by itself extend the model's context
window or create reasoning ability.

`train/causal_kv_anchor.py` is intentionally a small, no-training substrate
for this future experiment. It transports only exact tokens; no controller
parses, summarizes, selects, computes, or repairs their meaning. Because this
model's cached-attention fast path is causally exact only for a single new token
at a time, all updates are serially appended and mechanically compared against
full replays of the same token history. The original root cache remains
immutable so a matched anchor swap or zero-cache control cannot be hidden by
in-place state mutation.

This may be tested only after V10A and the semantic-capsule route establish
nonzero, source-deleted semantic transport. A valid experiment must compare:

1. **Exactness:** cached serial decoding and full replay have matching logits
   for every appended token; otherwise it is an invalid inference path.
2. **Semantics:** a model-authored anchor improves held-out source-deleted
   readout over a no-anchor control, while replacing it with a matched
   counterfactual anchor changes the answer in the solver-predicted direction.
3. **No controller shortcut:** token histories are forwarded verbatim; the
   controller is prohibited from converting facts to states or selecting among
   anchor candidates.
4. **Net resource accounting:** report original prompt tokens, model-authored
   anchor tokens, mutable tokens, cache bytes, prefill work, and full-replay
   work. `resource_accounting` reports exact token-position and per-layer
   causal-attention-pair counts for cached serial append versus full replay;
   GPU wall time remains a separate measured quantity. KV reuse is useful only
   if it saves end-to-end session work without concealing a longer context or
   another model call.
5. **Periodic re-anchoring:** any attempt to exceed a fixed context budget must
   ask the model to author a new compact anchor and rerun the same swap/zero
   controls. Copying an external summary into a fresh cache is disallowed.

This separates a real potential systems gain (persistent exact attention to a
model-authored state) from the rejected continuous-packet branches and from a
false claim of unlimited context. It becomes a context-scaling mechanism only
if model-authored re-anchoring preserves counterfactually useful state across
resets.

### Raw Workspace-Patching Baseline: No Simple Broadcast Register

`train/probe_digitwise_workspace.py` is the first diagnostic built from this
hypothesis. It does not train, generate a solver state, or claim to implement
the paper's Jacobian lens. On a teacher-forced DRS transition, it captures the
last-position residual after a selected block, replaces it with the residual
from a matched held-out transition whose correct next carry or digit differs,
and measures whether the target log-odds move toward that source state's
answer. A genuine result must be directional under symmetric A-to-B and B-to-A
swaps; a generic perturbation cannot satisfy that condition consistently.

The raw-200k local-MPS baseline is negative. Its frozen artifact
`artifacts/evals/digitwise_workspace_raw200k_mps_p4_layers.json` has SHA-256
`78b5efa4f3f7fe3ef10104de8d02fdee67f253c805c58f214a4cd1985c495875`.
It evaluates five held-out regimes, four matched pairs per regime, both carry
and digit fields, and symmetric directions: 40 directions per field/layer.
Carry swap deltas are only `+0.001` to `+0.028` log-odds with 18-22/40
directions positive; digit deltas are `-0.042` to `+0.0002` with 14-20/40
positive. A 10-direction smoke had seemed positive, but the expanded matched
sample removed it. Therefore the raw model does **not** expose a stable,
last-position, broadcastable local-state direction under this probe.

This does not say the model has no internal arithmetic features: the state can
be distributed across positions or represented nonlinearly. It does provide a
specific, preregistered contrast for the DRS/STRR interventions. Post-DRS
probe `687578` is queued after the existing wording, direct-interaction, and
NLL evidence chain with the identical 80-direction configuration. STRR may
advance only if its behavioral closed-loop gates and this matched diagnostic
are interpreted together; neither alone is a reasoning claim.

### Restricted Jacobian Digit Lens: A More Specific Causal Diagnostic

Whole-residual swaps are intentionally blunt: a negative result can mean that
the relevant state is distributed, that the swapped residual carries too many
unrelated features, or that there is no reusable state direction at all. The
paper's J-lens suggests a more selective test, but reproducing its full
cross-position, cross-corpus Jacobian construction would be unjustified for a
125M model before we establish a behavioral primitive.

`train/probe_restricted_jacobian_digit_lens.py` therefore implements a bounded
middle ground. On a frozen held-out DRS split, it averages the gradient from a
selected block's last prompt-position activation to each one-token *next-state
digit* logit. The discovery episode IDs are hash-separated from the evaluation
episode IDs. It then measures two disjoint evaluation conditions:

1. **Readout:** can the ten averaged directions rank the correct next digit
   above chance on new episodes?
2. **Causal swap:** on matched pairs with the same local operation, width,
   position, and carry but different correct output digits, does swapping only
   the two corresponding gradient-direction coordinates shift the target's
   next-token log odds toward the source digit more than a fixed shuffled-label
   control?

The raw-200k four-layer baseline is negative. From 80 hash-separated discovery
gradients (eight per digit), all four layers have exactly 20/200 top-1 readout
on separate contexts, the ten-way chance count. Their 40-direction matched
causal effects above a shuffled-label control are +0.108, +0.217, +0.240, and
+0.286 log-odds at layers 13/17/21/25, respectively, but their descriptive
SEMs are +0.252, +0.339, +0.326, and +0.330 with only 20-21/40 directions
favoring the signal. The immutable artifact is
`artifacts/eval_history/restricted_jacobian_digit_lens_raw200k_mps_l13_17_21_25_d8_r20_p4.json`,
md5 `d5c61ead369acc0e1fbf0daf6006cb53`. Thus the raw model has no detectable
reusable, verbalizable next-digit direction under this restricted method. That
is a constraint on the project hypothesis, not a full J-lens result or proof
that all internal state is absent; a distributed or nonlinear code can evade
the test.

The job wrapper remains an isolated diagnostic, not a semantic workspace probe
or evidence of general reasoning. It should next run only on a checkpoint that
first passes V10A's behavioral semantic-primitive gates. A positive restricted
result still cannot authorize CWI or a capability claim without the
already-preregistered behavioral, counterfactual, and multi-readout gates.

## Conditional Technique: Counterfactual Workspace Induction

The paper's counterfactual-reflection result motivates a distinct follow-on
experiment, **Counterfactual Workspace Induction (CWI)**. It is deliberately
not another request for the model to print a chain of thought. Starting from a
checkpoint that can already execute a local register transition, CWI would
append a *training-only* reflection turn after a fixed-tape local-state context:
"Which one invariant distinguishes the legal next register from this
grammar-valid foil?" The supervised continuation names the concrete local
operator, input digits, carry/borrow, result digit, and immutable fields that
must be preserved. Loss is computed only on that appended reflection; at
evaluation, the reflection question is absent and the model must perform the
ordinary direct state update.

The critical foil is not malformed text. It is a state-shaped candidate that
changes exactly one semantic field: an incorrect carry, a wrong `r[p]`, an
unjustified program-counter change, or a rewritten immutable tape. Thus the
reflection cannot be solved from style or grammar. If it transfers to the
unreflected task, it would be evidence that training a reportable disposition
changed the intermediate computation used for action, the limited phenomenon
the paper tests at scale.

CWI is **conditional** on a positive STRR primitive gate. It must be compared
from the same STRR checkpoint and token budget against: (1) a syntax-only
reflection with no local arithmetic content, (2) a reflection-label permutation
control, and (3) an equal-compute direct-transition continuation. Advancement
requires an improvement on held-out unreflected state loops and paired
counterfactuals, no loss of distinct register readouts, and a matched positive
change in the residual-patching diagnostic. A reflection that only improves its
own prompted explanation is rejected. This would make CWI a test of
workspace-shaped computation, not a new narration style.

`train/counterfactual_workspace_protocol.py` now makes the reflection premise
mechanically precise. Starting from a fixed tape and current register, it
derives the legal successor and then constructs a candidate that is
grammar-valid but differs in exactly one of four semantic ways: carry, active
result digit, program counter, or immutable tape. The supervision target
reports the verdict and the expected/observed value at the active position.
Thus the reflection cannot succeed by detecting malformed text or predicting a
constant `illegal` label.

The CPU-only builder/auditor pair now has a full local dry-run against the
admitted factor corpus: 682,957 train reflection rows and 52,200 held-out
reflection rows, with every row semantically rederived by an auditor that does
not import the builder. It found 0 malformed rows, duplicate identities,
normalized duplicate prompts, exact prompt hits, or 13-gram train/held-out
hits; it covered all 3,400 legal local contexts and preserved all 26,100
base/counterfactual held-out foil pairs. The durable Stokes wrapper refuses to
write over artifacts and requests CPU only. This is still corpus admission,
not an SFT, checkpoint, H100 allocation, workspace result, or relaxation of
the STRR/CWI gates above.

## Conditional Representation Control: Token-Native Delta Ledger

The static-tape register removes immutable input copying, but its next state
is still a **21-token** BPE continuation (`dwr:p=...;c=...;r=...;z=...`). The
existing textual append-ledger delta is shorter but still costs **14 tokens**.
At the observed state-error rates, those serial output decisions are a
plausible exposure-error bottleneck independent of arithmetic. The proposed
**Token-Native Delta Ledger (TNDL)** therefore encodes one model-authored
transition as exactly three *existing* atomic special tokens, in fixed field
order: next position, carry/borrow, and result digit. It does not add a
tokenizer entry, alter the model architecture, or let a controller calculate
anything. The controller only validates that exactly three code tokens were
emitted, retains their exact sequence, and supplies the last emitted triple on
the next update; the model must still derive the carry and digit from the
unchanged operand tape. The full emitted ledger is supplied only for final
readout. Because this carrier has intentionally tiny finite entropy, final
prompts repeat an opaque hash of the immutable tape between triples. This
prevents a train and held-out prompt from sharing a long carrier substring;
the controller never decodes, predicts, or computes with the hash, and the
same rendering is required in all matched controls.

This deliberately differs from DCRD. DCRD asks the small model to bind random
natural-language codebooks and perform reversible translations, which tests a
much harder semantic-binding hypothesis. TNDL instead holds the mapping fixed
and isolates whether the previous negative results are dominated by state
serialization length. It is also a more atomic version of ADL: no textual
field labels, result-tape rewrites, or controller-generated arithmetic are
introduced. Its initial scope is width 4/6 train and width-8 held-out; any
claim about longer context must wait for a successful first-level ledger.

TNDL is useful only if it is compared against a text ADL and static-tape
register from the same raw checkpoint, update budget, operands, held-out
counterfactuals, and controller wording. A positive result requires materially
higher complete closed-loop and paired-intervention accuracy, not merely more
well-formed three-token responses. A second fixed permutation of the ten code
tokens is required before claiming that the result is not an accidental
association with the tokenizer's pre-existing special-token semantics. A
passing first-level carrier would be a primitive transport result, not proof
of language reasoning or context scaling; only then can it be combined with
the CWI and semantic compiler gates.

## Hypothesis: Proof-Carrying Deliberation

The next distinctive mechanism is **proof-carrying deliberation (PCD)**. A
tiny model should not be expected to invent and maintain a long free-form chain
of thought. It may be able to build a small executable thought one local action
at a time if it learns both sides of the action:

1. **Propose:** emit a typed, compact next state.
2. **Verify:** inspect a grammar-valid candidate state and identify whether it
   is the single legal successor, including the first violated local field.
3. **Deliberate:** generate several candidates itself, ask itself to verify
   each, and select only according to its own verdict. The controller only
   carries exact model text and enforces syntax; it never computes, repairs, or
   inserts a correct candidate.
4. **Compact:** periodically replace raw deltas with a model-authored proof
   block whose fields are independently locally checkable on the next turn.

This differs from ordinary chain-of-thought distillation. The model is trained
on counterfactual *near misses* that are the same length and grammar as correct
states, so it cannot win from style, answer position, or malformed text. A
verifier that cannot distinguish these cases is not useful, even if it can
recite a state template.

## First Falsification Gate

`train/probe_transition_verifier.py` is the raw feasibility probe. It presents
balanced valid and grammar-valid invalid DRS transitions. Invalid candidates
change only a local digit, carry/borrow, or immutable operand tape. It reports
accuracy by wording, label, and near-miss type from verbatim completions.

This probe does **not** train the model and does not yet establish PCD. It
answers a narrower question: is local verification materially easier for the
raw model than free-form state generation? The answer determines whether a
counterfactual verifier curriculum is worth an isolated H100 ablation.

### Gate 0 Result: Raw Verification Is Also Absent

The raw 200k checkpoint fails the first probe. On 48 balanced, grammar-valid
DRS transitions it emits no usable verdicts (`0/48`). Its verbatim responses
are bare digit strings or repeated document fragments. That alone could be an
answer-mode failure, so the exact two completions were also scored by mean
token likelihood. The model prefers `verdict=valid` on every case, yielding
exactly `24/48 = 50%` on the balanced labels. It has no raw local-verification
signal under this contract.

Artifact: `artifacts/eval_history/transition_verifier_likelihood_raw200k_20260713_mps.json`,
MD5 `fb7bbdbb1fa16104117f09c6c3faa07c`.

The consequence is not to declare PCD successful by construction. It becomes
a conditional supervised experiment: only consider it after the current DRS
SFT proves that the model can learn a core local transition. If DRS cannot do
that, there is no basis to expect a jointly trained generator/critic loop to
bootstrap itself.

## Required Causal Evidence Before Any Claim

A future PCD ablation must keep these gates:

- Solver-generated train and held-out operand tapes, widths, vocabulary, and
  controller wording are disjoint; every controller prompt is overlap-audited.
- Negative states are grammar-valid and balanced by error type. Label order,
  wording, and candidate position must be randomized.
- The evaluator uses candidates sampled by the model itself. It may not give
  the model a solver-supplied correct option at inference.
- Report greedy generation, sampled generation, and model-verifier reranking
  on the identical candidate pool. The external solver scores afterward only.
- Require improvement on held-out state transitions, complete closed loops,
  paired counterfactuals, and natural wording. A template-only score cannot
  advance the mechanism.
- Run a label-shuffled verifier control with the same data, steps, and compute.
  If it performs equally well, the verifier learned a surface prior rather
  than an executable invariant.

Even a passing PCD result would establish only narrow, model-authored
algorithmic deliberation. Broad natural-language reasoning remains a separate
claim and needs direct-interaction and public held-out evidence.

## New Hypothesis: Counterfactual Bisimulation Compiler

The repeated negative results identify a sharper problem than "the model needs
more chain of thought." The model has not learned a representation that is
*causally sufficient* for future work. A state string can be reproduced as a
template, and an answer can be imitated from a familiar prompt, without the
state actually carrying the facts needed to update, query, or explain a new
situation. V7, VRWM, the semantic-capsule raw controls, and the continuous
packet controls each exposed a different version of this loophole.

The next mechanism to investigate, conditional on the current DRS learnability
gate, is a **Counterfactual Bisimulation Compiler (CBC)**. It uses the model's
own token output as a compact recurrent register, but makes that register
answer to four linked obligations rather than one formatting target:

1. **Compile:** map a natural-language history to a canonical typed state.
2. **Advance:** map that state plus one new event to the next typed state after
   the history has been removed.
3. **Read out:** answer several previously unseen questions using only the
   typed state, never the original history.
4. **Explain the delta:** given two adjacent states, name the single event or
   field change that connects them.

For every episode, a paired paraphrase describes the same world with unrelated
surface wording and an independently generated counterfactual changes one
causal fact. The canonical state must be identical for paraphrases and differ
only in the affected fields for the counterfactual. This is the operational
meaning of *bisimulation* here: equivalent descriptions must induce the same
future behavior under every held-out event/query; a changed fact must change
only the future behavior that depends on it. The external generator and
verifier create labels during training and score results afterward, but the
runtime controller only transports exact model text, drops the source, and
enforces grammar. It does not answer a query, repair a state, rank candidates,
or inject a correct field.

### The Crucial New Constraint: State Interchange

The easy way to fake a state curriculum is to answer from the current prompt
and treat the rendered state as decoration. CBC therefore adds an *interchange*
operation that is not present in ordinary chain-of-thought SFT. For one latent
world, generate two independently worded histories, compile each to a state,
then give the first state's output to a query drawn from the second history.
Because the worlds are semantically identical, the answer must remain correct.
For a counterfactual world, perform the same exchange after changing exactly
one causal fact; now exactly the dependent answers must change. The model is
not shown the original history for either readout.

This turns "does the model emit a plausible state?" into a causal intervention:

1. Same-world interchange must preserve answers across wording.
2. Cross-world interchange must fail in the exact directions predicted by the
   changed fact, rather than merely changing output style.
3. Zeroed, shuffled, and counterfactually mismatched states must lose the
   corresponding advantage on the *same* queries.
4. An inverse-delta prompt must recover the changed field from adjacent states,
   so a lossy answer-only summary cannot pass by accident.

The resulting metric is a **state-necessity margin**: normal model-authored
state accuracy minus matched zeroed/shuffled/mismatched-state accuracy, with
the paraphrase and counterfactual rows reported separately. A high ordinary
answer score with no margin rejects the mechanism. This is the central
distinction from all earlier state experiments in this project.

### Why This Is Different From Earlier State Work

- **Not V7:** V7 rewards a rendered state/answer contract. CBC requires the
  state to survive source deletion and support multiple forward, inverse, and
  query tasks that were not present in the compiler prompt.
- **Not the rejected capsule control:** that was a raw-capability test. CBC is
  a supervised curriculum and treats compilation, transition, and decoding as
  mutually constraining tasks rather than assuming a raw model already knows
  the protocol.
- **Not continuous memory:** the retained object is readable model-authored
  text. Its content, causal effect, and failure modes can be independently
  audited. A shuffled or zeroed state control can therefore falsify the claim.
- **Not ordinary CoT:** a long rationale is not sufficient. The compact state
  must make new predictions after the rationale and source are gone.

### Curriculum, Not a One-Shot SFT

CBC should be staged only after DRS tells us whether the current model can
learn a local symbolic transition at all:

1. **Primitive executor:** DRS establishes exact local transition learning on
   a fixed canonical syntax. This is the active gate, not an assumed ability.
2. **Semantic compiler:** two to four natural-language facts compile into a
   compact state; paraphrase pairs, distractors, and randomized field names
   block lexical copying.
3. **Recurrent world model:** only the prior state plus a new event is
   available for each update. Training alternates forward update, inverse
   delta, and query readout examples so no single answer template dominates.
4. **Compaction under pressure:** after several updates, the model emits a
   shorter canonical state. The dropped trace is never reintroduced. Held-out
   questions include facts that are not asked during compaction, making an
   answer-only summary insufficient.
5. **Interchange before self-check:** generated states must solve queries from
   a separate paraphrase of the same world and fail predictably when swapped
   with a counterfactual world. This is the first point at which a state can be
   called causally useful rather than merely well formatted.
6. **Self-check only after competence:** a verifier/repair role is trained on
   balanced grammar-valid near misses and then asked to judge *model-sampled*
   states. This is where PCD can become a component, not a premise.

The phase-3/4 data must progressively randomize entities, field order,
paraphrases, distractors, operation order, and query wording. It should also
include reversible pairs: state-to-language descriptions and language-to-state
compilation must agree on the same held-out world. This is deliberately a
harder requirement than exact state formatting, because the target property is
semantic invariance rather than a learned serialization.

### Preregistered Advancement Gates

CBC is not authorized for a flagship change on a positive training loss or a
default-template score. Before a follow-on stage, report all of the following
on disjoint worlds, vocabularies, field names, and controller prompts:

- DRS core and held-out results, including first transition, full loop, final
  answer, and paired intervention. A weak primitive means we first compare the
  lower-copy ADL curriculum rather than build a semantic stack on sand.
- Compilation equality for paraphrase pairs and minimal, causal state change
  for counterfactual pairs.
- Source-free forward updates, inverse-delta accuracy, and multiple unseen
  query readouts from the same generated state.
- Same-world state interchange plus cross-world counterfactual interchange.
  Normal versus zeroed, shuffled, and mismatched-state margins must be
  measured on the identical generated states. No margin means the state is
  decorative, irrespective of answer accuracy.
- A label-shuffled verifier control with matched compute. Equal performance
  rejects the claimed self-checker.
- Fresh direct interaction with ordinary arithmetic, code, logic, and state
  questions. Transfer is a requirement, not an aspirational extrapolation.

This is a new project hypothesis, not a claim of field-wide novelty or a claim
that the model already possesses the mechanism. Its value is that it gives a
small model a concrete route from language to a compact, revisable, causally
testable token state. If the gates fail, the failure will identify whether the
barrier is primitive execution, semantic compilation, recurrence, compression,
or self-verification instead of producing another ambiguous SFT score.

### CBC Protocol/Audit Preflight: 2026-07-13 15:24 EDT

The CBC substrate now exists as an isolated CPU-only protocol,
`train/bisimulation_compiler_protocol.py`, plus a generator and independent
auditor.  The protocol uses a canonical `cbc:key=value;key=value` carrier and
a distinct `cbc-delta:` grammar.  It has two source-description compilation
interfaces, source-free update and inverse-delta prompts, and a final query
that receives only the carrier.  Every held-out episode carries a paired
counterfactual whose initial first field changes by one while its operation
sequence is identical and its final answer must differ.

The medium local preflight generated **1,000** train episodes, **16,000**
train rows, and **120** held-out paired-counterfactual episodes.  The auditor
independently reconstructed every compilation target, state update, delta,
readout, shared operation sequence, and counterfactual relation.  It found
**0** invalid train rows, **0** invalid held-out episodes, **0** normalized
duplicate prompts, and **0** exact or literal 13-gram train/held-out prompt
hits.  Corruption tests prove that it rejects both changed train targets and a
semantically valid-looking counterfactual with a mismatched operation sequence.
No model checkpoint, controller rollout, or GPU job has been created. CBC
remains conditional on a positive causal-result gate rather than a format
score.

The matching transport-only controller is also preflighted.  It accepts only
a parsed model-emitted state, renders the next source-free prompt around that
text, and halts on an incorrect or malformed emission.  Its test covers
primary rollout, inverse-delta checks, same-world compiler interchange, and a
real cross-world counterfactual carrier swap on the identical source-free
query.  The swap takes the *model-emitted counterfactual terminal state* and
requires the query to produce the counterfactual answer rather than the normal
answer.  Re-reading the normal state would only restate ordinary rollout
accuracy and is explicitly not counted as a causal result.  A bad first state
terminates the run; it is not canonicalized into a solver answer or repaired.
This makes CBC's later state-necessity measurement executable rather than an
informal data claim.

### CBC Build and Evaluation Readiness

The CPU-only Stokes build wrapper creates a fresh candidate only after an
independent audit passes: it requires zero malformed rows or held-out episodes,
zero exact and 13-gram train/held-out prompt hits, all five training roles
(two compilers, update, inverse delta, readout), and all 4/8/12-step held-out
regimes.  The initial build uses 4,000 episodes per train domain and 200 per
held-out domain, which exceeds 100,000 training rows without consuming a GPU.
Stokes job `738468` completed this build without consuming a GPU. The immutable
candidate contains **16,000** train episodes / **256,000** training rows and
**600** held-out paired-counterfactual episodes: 198 length-4, 201 length-8,
and 201 length-12. The independent audit found zero invalid rows or held-out
episodes, duplicates, exact split prompts, or literal 13-gram split hits.
The train / held-out SHA-256 values are
`6013f5118b00c3b88afbe2af892b7e25867a4a5e5a2d1c5882ee635564326c02` /
`163e60398f239ab4058129ef135350d3d5509ea1dc309417d9f85dabbdf59256`.
The full data and the two small admission records are mirrored locally and on
Newton. This is data admission only, not an SFT or capability result.

`train/eval_counterfactual_bisimulation.py` now measures the controller with a
checkpoint on a deterministic balanced slice.  It records compilation A/B,
source-deleted closed loops, inverse-delta checks, same-world interchange,
counterfactual interchange, and the true cross-world carrier intervention.
No SFT should be proposed from CBC unless those held-out metrics show a
nonzero causal state-necessity margin over malformed, swapped, and
counterfactual-mismatched carriers.

### DRS v2 Coverage Diagnosis: 2026-07-13 15:38 EDT

The new read-only position-coverage audit resolves a material ambiguity in the
ongoing DRS core evaluation.  The immutable v2 train corpus has **zero**
transition inputs containing digits **3–9** at the most-significant position
of either operand tape for width 4 or width 6; those positions were limited
to values below `3000` and `300000`.  In contrast, each `value_ood` regime
uses `7000–9999` or `700000–999999`.  All **600** paired value-OOD local
transition contexts per width therefore have an unseen exact local arithmetic
context, and the audit records **1,200** unseen digit-position events per
value-OOD regime.  Width-8 is a true compositional extrapolation with **4,800**
unseen local contexts.

This does not excuse a poor result; it prevents a false conclusion.  DRS v2
can only establish in-distribution fixed-register execution.  Any next DRS
curriculum must stratify digit support by width, position, operand tape,
operation, and carry/borrow context before its value-OOD result can be used as
evidence about algorithmic generalization.  No revised corpus or GPU job is
created before the current serialized DRS chain finishes.

### DRS v3 Minimal Transition Basis: 2026-07-13 15:45 EDT

The corrective candidate is deliberately not simply “more random arithmetic.”
`generate_digitwise_basis_v3.py` constructs complete arithmetic episodes whose
designated transition enumerates every **reachable** local tuple of `(width,
operation, position, carry/borrow, left digit, right digit)` for width 4 and
width 6. It keeps full operand and result tapes, so the model still has to
preserve a recurrent state rather than answer a disconnected lookup question.
The paired held-out sets use unseen full tapes at the same local-support basis
(`recombine_w4`, `recombine_w6`) and an unseen width (`width_ood_w8`).

Its independent admission audit rechecks every arithmetic row and held-out
counterfactual, then independently requires all **3,400** reachable contexts.
The medium local preflight with two tape variants produced **6,800** complete
episodes and **77,946** rows: 0 malformed rows/episodes, 0 normalized duplicate
prompts after deterministic deduplication, 0 exact or literal 13-gram split
hits, and all 3,400 contexts present. A corruption test deleting every
instance of one otherwise valid context is rejected. This is a staged
learnability control, not a model result, and it has no durable corpus, SFT,
or GPU allocation before the current DRS core/held-out/direct evidence chain
has finished.

The future one-epoch launch path is now static-tested but deliberately
unsubmitted. `sft_digitwise_basis_v3.sbatch` independently binds the candidate
data and held-out SHA-256 values to its admission audit, requires all 3,400
contexts and the three prescribed held-out regimes, rejects any contamination
or structural counter, and proves the exact inference/SFT prompt boundary
before using CUDA. This makes a later causal test reproducible; it does not
promote the hypothesis, create a durable corpus, or reserve a GPU.

### Static-Tape Recurrent Register (STRR): 2026-07-13 16:04 EDT

DRS exposes a second representation confound besides its missing local
contexts. The previous `dws:` state makes every self-authored transition copy
the immutable `a` and `b` operand tapes, even though only the control register
and result tape change. That can reward long-string reproduction more than
local execution. **STRR** factorizes these roles: the original problem is a
fixed `dwt:` tape containing opcode, width, and the two operand tapes; the
model emits only the evolving `dwr:` register with `p`, `c`, `r`, and `z`.

The transport-only controller is deliberately constrained. It re-sends the
unchanged tape from the episode and forwards only a parsed model-emitted
register. It never applies the arithmetic transition, replaces a malformed
register, or chooses among outputs. Thus the test asks whether preserving
immutable evidence in context lets a small model carry a compact dynamic state
more reliably, rather than delegating arithmetic to the controller.

Its independently checked medium preflight uses the same **6,800** complete
episodes / **77,946** rows / **3,400** reachable local contexts and **120**
paired held-out counterfactual episodes as the matched basis smoke. The
generator and auditor report 0 malformed rows or episodes, duplicate prompts,
counterfactual mismatches, exact split hits, or literal 13-gram hits; deleting
all examples of one valid local context makes admission fail. The matched
closed-loop evaluator is static-tested and can retain capped success/failure
transcripts separately for each regime. Its matching staged SFT wrapper binds
the immutable data and held-out hashes to that audit, verifies exact inference
and SFT prompt-token boundaries, refuses existing outputs, and requires a real
CUDA allocation. STRR is still an unsubmitted candidate: it has no durable
corpus, SFT checkpoint, or GPU allocation. It becomes admissible only after the
running v2 core, held-out wording, and transcript chain distinguish coverage
failure from a deeper execution failure.

### Complete DRS v3 Basis Artifact: 2026-07-13 16:20 EDT

The full eight-variant coverage control is now immutable and mirrored locally
and on Newton, but has not been submitted for SFT. It has **27,200** complete
episodes / **311,127** deduplicated rows, covers **3,400 / 3,400** reachable
local contexts, and keeps **900** paired held-out episodes (300 each of
`recombine_w4`, `recombine_w6`, and `width_ood_w8`). Its independent audit
reports zero invalid rows or episodes, normalized duplicate train prompts,
missing contexts, exact train/held-out prompt collisions, or held-out
13-gram collisions. The train and held-out SHA-256 values are respectively
`b785866bf24813272d346e4a3bb717d4156b01a59a4dd8ccaf450733267368f6` and
`f2fcfcae41b55aa82dd360036bd8c9c00ed6e4ca442debec1c85ed282e50dfe1`.
This artifact tests the coverage confound in the observed v2 value OOD gap; it
does not establish algorithmic generalization by itself and remains gated on
the active transcript evidence chain.

### DRS v2 Core Result: 2026-07-13 16:25 EDT

The canonical held-out core evaluation is a positive narrow mechanism result
and a negative generalization result. The isolated checkpoint gets **275/500**
final answers: 100/100 on fit width 4, 98/100 on fit width 6, 34/100 and
43/100 on the two unseen-value regimes, and 0/100 on unseen width 8. However,
the first model-authored state is correct on **497/500** episodes, including
98/100 width-8 episodes. The model begins from valid local arithmetic but
accumulates errors over later turns. This shifts the immediate causal priority:
the complete v3 basis remains needed to isolate unseen interior contexts, but
the first corrective SFT should be **STRR**, which removes immutable tape
rewriting and thereby directly tests multi-step state transport. This remains a
conditional decision until held-out wording and transcript probes complete.

### Complete STRR Artifact: 2026-07-13 16:23 EDT

The full static-tape/recurrent-register corpus is immutable and mirrored
locally/Newton: **27,200** episodes / **311,127** deduplicated rows, **3,400 /
3,400** required local contexts, and **900** paired held-out episodes split
evenly across recombine widths 4/6 and width-8 OOD. Its independent admission
audit reports zero invalid rows or episodes, normalized duplicate prompts,
counterfactual mismatches, missing contexts, exact hits, or 13-gram hits.
Train SHA-256 is `82245615f0849c3270f99f2db85c604ff46cb2c3dfb14f0ab3660dff3eb0d3ec`;
held-out SHA-256 is `a699ac58ad8184f4dc23dcfa317cd6e7b8f7d4ef453dcbf1ae21201901e0948a`.

### Complete-Basis Matched Control Reactivation: 2026-07-15 03:04 EDT

The previously admitted DRS-v3 and STRR corpora are now running only as
matched empirical controls while R12 remains theory-gated. DRS chain
`689496 -> 689497` tests whether exhaustive coverage of all 3,400 reachable
local decimal transitions is enough for unseen full-tape recombination and
width-8 rollout. STRR chain `689498 -> 689499` uses the same local support but
keeps the immutable operand tape in context and asks the model to transport
only the changing register. Both start from immutable raw 200k, write fresh
isolated outputs, and evaluate all 300 episodes in each recombination-width
4/6 and unseen-width-8 regime.

This pair does not claim a new R12 primitive. Its purpose is to establish the
strongest known tied-recurrence/control floor: whether complete local support
plus reduced copy burden can produce real length extrapolation at all. Any
future invention must beat the stronger arm, not the incomplete v2 DRS result.
It is not trained or allocated and should only be submitted as an isolated
transport control after the current transcript gate.

## Conditional Hypothesis: Dual-Code Reversible Deliberation

The missing ingredient may be neither a longer trace nor a larger hidden
packet. A small model can make a locally plausible but globally wrong state
transition, then repeat that error with high confidence. An ordinary
self-critique is weak evidence because the same decoder can reproduce its own
mistake. The proposed remedy is **Dual-Code Reversible Deliberation (DCRD)**:
the model carries one compact state in two deliberately incompatible token
codes and must close a reversible loop across them before accepting a step.

For each episode, the generator creates two canonical encodings of the same
machine state. They use independent field order, delimiters, role names, and
digit symbols. A short static codebook may be retained at every turn, but the
problem history may not. The codebook is randomized per episode and held-out
codebooks contain symbols, orders, and bindings never used during training.
That prevents a second rendering from becoming an identity-copy shortcut.

The single model learns four tagged operations:

1. `FWD-A`: advance an A-code state by one local transition.
2. `A->B`: transcode the resulting state into the unrelated B-code.
3. `REV-B`: recover the preceding B-code state from the B-code successor.
4. `B->A`: transcode the recovered predecessor back into A-code.

At inference, the controller forwards exact model text between these calls,
checks only that the last A-code string is byte-identical to the A-code input,
and either accepts the proposed successor or abstains. It never computes a
transition, chooses a digit, repairs a state, ranks candidates, or supplies a
correct alternative. A later extension may use bounded sampling to obtain
another proposed successor, but it may never use a solver at runtime.

This is not a proof of correctness. A wrong transition can still be internally
reversible. Its purpose is narrower and testable: force the model to represent
state semantics through two non-copying channels, then turn agreement into a
reliability signal rather than an ungrounded natural-language self-critique.

### Why It Is Not Another Formatting Control

- **Different syntax is functional, not cosmetic.** The A/B codebooks and
  field orders vary per episode, and a held-out codebook is required. A model
  that memorizes a fixed serialization cannot transcode or close the loop.
- **The round trip has an asymmetric failure surface.** `FWD-A` and `REV-B`
  operate in opposite temporal directions; the model must preserve enough
  information for an inverse operation after source deletion.
- **Acceptance is evaluated as a decision, not as a trace score.** Report
  unconditional accuracy, accepted accuracy, coverage, and the improvement in
  accepted accuracy over an equal-call baseline. A mechanism that merely
  abstains is rejected.
- **It has adversarial interventions.** Replace one B-code field, swap a B
  state from a matched counterfactual episode, or permute the B codebook.
  Correct acceptance must fall and dependent answers must change in exactly the
  solver-predicted direction. Invariance to these changes means the second
  code is decorative.

### Required Controls And Advancement Gate

DCRD is conditional on a positive DRS core execution result. It must remain an
isolated experiment with a fresh output directory and no flagship path. Before
it can motivate a semantic CBC compiler, all of the following must hold on
unseen operands, widths, controller wording, and per-episode codebooks:

- The basic DRS model must beat raw zero on first transitions, closed loops,
  final answers, and paired counterfactual interventions. Otherwise DCRD only
  adds an elaborate checksum to a nonexistent executor.
- DCRD's accepted states must have materially higher exact solver accuracy than
  its unfiltered proposals *and* an equal-call control that simply repeats the
  A-code lane. Coverage must be reported with confidence intervals.
- `A->B->A` alone, a shuffled B-codebook, and an identity-format B lane are
  matched controls. Equal performance rejects the claimed semantic second
  channel.
- The model must fail closed under a one-field B-code corruption and reject
  counterfactual B-code interchange whenever the query depends on the changed
  field. Passing ordinary answers without this sensitivity is a failure.
- A forward/reverse round trip may never be reported as a reasoning score by
  itself. Only correct accepted answers on held-out tasks and fresh interactive
  probes count as capability evidence.

If this fails, we learn whether the bottleneck is primitive transition
learning, codebook binding, inverse dynamics, or correlated self-error. If it
passes, it supplies a compact, model-authored state and an internal
error-detection signal that can be carried into CBC's language compiler. This
is a project hypothesis, not a novelty claim and not authorization to modify
the live pretraining run.

### Implementation Status

The CPU-only protocol substrate is implemented in
`train/dual_code_reversible_protocol.py`. It provides deterministic per-episode
A/B codebooks, channel-specific serialization grammars, strict code-specific
parsers, source-free prompt builders, and a solver-only inverse transition for
data construction and scoring. Train and
held-out codebooks use disjoint alias vocabularies and structurally distinct
instruction interfaces. The generator and independent auditor bind prompt
style to codebook vocabulary for the training corpus, while the protocol still
permits crossed style/codebook combinations for future attribution controls.
This makes literal train/held-out n-gram overlap an auditable data failure
rather than a hidden template confound.

`pipeline/generate_dual_code_reversible_v1.py` and its independent companion
`pipeline/audit_dual_code_reversible_v1.py` now construct and semantically
recompute every forward, transcode, inverse, and readout target. A local
1,000-episode preflight generated 21,000 training rows plus 200 held-out paired
counterfactual episodes: the auditor found 0 invalid rows or episodes, 0
normalized duplicates, 0 exact held-out prompt hits, and 0 literal 13-gram
hits. The smaller end-to-end contract has the same result. These are only
generator/auditor checks: no durable DCRD corpus has been admitted and no
controller rollout, SFT, or GPU job has been submitted. The DRS causal chain
still decides whether this branch is worth launching.

`train/test_dual_code_reversible_protocol.py` exercises codebook separation,
encode/decode round trips, canonical-state leakage rejection, prompt-style
binding, and 120 randomized inverse-transition cases. The implementation is a
precondition for a later causal experiment, not evidence that the model can use
the protocol.

## Active Architecture Hypothesis: Verbalizable Recurrent Workspace

The next isolated experiment is a **Verbalizable Recurrent Workspace (VRW)**.
It targets a failure shared by the closed soft-token, source-dropped packet,
typed-state, and operator-trace branches: adding a carrier or teaching a trace
does not prove that the frozen decoder can read a causally necessary internal
state. VRW changes that interface while leaving the 125M base immutable.

The design is informed by the sparse, reportable workspace observations in
<https://transformer-circuits.pub/2026/workspace/index.html>, but it does not
claim to implement that paper's J-lens. Its top-k normalized unembedding basis
is an explicit late-layer verbalizability approximation and is evaluated as an
engineering hypothesis.

### Mechanism

- The pretrained base is frozen. The ordinary source prompt remains visible to
  all upper transformer blocks, so the experiment does not manufacture a hard
  source-removal bottleneck that the base was never trained to cross.
- At block boundary 19, four 96-wide slots cross-attend only to prompt
  residuals. One shared GRU cell updates those slots four times. Recurrent
  depth therefore adds compute without adding step-specific parameters.
- Answer tokens never enter scratch construction. The state is read only at
  answer-predicting positions through query-conditioned slot attention.
- The readout is projected onto the top eight frozen normalized unembedding
  directions with nonnegative mixture weights, rescaled to local residual RMS,
  and applied through one signed scalar gate. The gate starts at exactly zero,
  making the initialized wrapper exactly equal to the frozen base.
- Only adapter parameters are optimized. Checkpoints store the small adapter,
  immutable base/data hashes, architecture values, and an exact initial-adapter
  hash rather than copying or drifting the base.

### Causal Controls

The recurrent candidate and reset control use the same checkpoint, data,
seed, shape-bucketed batches, optimizer, parameter count, initialization, and
four cell executions. In the reset arm every execution starts from the learned
initial slots; their identical outputs are averaged so every call participates
in backward while no information can accumulate across steps.

Held-out evaluation keeps the source visible and measures teacher-forced NLL,
token accuracy, and exact answer sequences under:

1. adapter disabled;
2. one recurrent step;
3. the adapter's trained depth and trained recurrence mode;
4. recurrent candidate reset at inference;
5. zero scratch state; and
6. scratch states shuffled between matched-shape examples.

The locked comparator requires all of the following before autoregressive
evaluation: at least 0.05 fit-IID NLL advantage over the reset fit; at least
0.03 depth-OOD NLL advantage; at least 0.05 state-necessity margin over the
strongest zero/shuffle control; at least 0.03 within-model depth-OOD advantage
over one-step/reset inference; and exact-sequence wins in at least two of four
held-out regimes. Passing these gates only admits state-swap generation and
manual interaction. It is not itself a reasoning result. Failure closes VRW
without scaling it or modifying the protected pretraining writer.

### Implementation

The isolated implementation is in `train/causal_recurrent_scratch.py`, with
paired trainer, NLL evaluator, locked comparator, Slurm wrappers, and CPU unit
contracts. The first canary is capped at 8,192 admitted answer-only operator
examples per arm (1,024 updates at batch size eight) from immutable 200k. No
VRW checkpoint or capability result exists until both arms complete and the
hash-bound comparator runs.

### VRW Result: 2026-07-14 13:08 EDT

The bounded experiment is complete and **VRW is rejected**. The recurrent and
reset arms used the same immutable 200k base, admitted answer-only corpus,
8,192 examples, 1,024 updates, seed, 297,217 adapter parameters, and exact
initial-adapter SHA-256. The reset arm was trained and evaluated in reset mode;
the evaluator did not accidentally enable recurrence.

On 224 held-out cases, reset beats recurrence by 0.26736 fit-IID NLL and
0.26769 depth-OOD NLL. Within the recurrent adapter, four steps improve
depth-OOD NLL over one step/reset by only 0.01446, below the locked 0.03 gate.
Shuffling state between matched-shape examples changes all-case NLL by only
0.00377, below the 0.05 state-necessity gate. Neither model gets one exact
answer sequence in any regime. Every advancement gate is false, so no
autoregressive state-swap evaluation is permitted.

This rejects the specific hypothesis that a sparse token-aligned readout plus
final-answer supervision is enough to identify a useful recurrent workspace.
The reset adapter's substantially better NLL shows that the readout can learn a
one-step prompt-conditioned correction. Repeated GRU updates instead erase or
homogenize useful information, and the near-invariance to shuffled state shows
that the learned recurrent state is not prompt-specific enough to mediate an
answer. Future work must supervise or structurally identify local state
transitions; adding more answer-only recurrent depth is blocked.

## Active Architecture Hypothesis: Causal Microcode Bottleneck

The strongest positive mechanism evidence is not a public benchmark score. In
the Digitwise Recurrent Scratchpad, the first local state was correct on
497/500 episodes, including 98/100 width-eight cases, while repeated textual
rollout ended with only 275/500 correct answers. The model can select a local
transition, but serializing and rereading an exact state accumulates errors.
VRW then showed that final-answer loss does not identify a prompt-specific
recurrent latent state: reset beat recurrence and shuffled state was nearly
invariant. Causal Microcode Bottleneck (CMB) tests a different decomposition.

### Mechanism And Claim Boundary

- The 125M base is frozen. Its layer-19 hidden state at each event-line end and
  the final query-line end feeds shared operation/query classifiers. The
  compiler predicts one of nine register-relative operations per event and one
  of five readout operations per query.
- A deterministic lexical frontend extracts only the two standalone initial
  integers, at most one standalone integer per event, and line boundaries. It
  does not classify operations, bind registers, execute arithmetic, or select
  the answer. This supplied structure is reported rather than hidden.
- Execution uses two eight-digit categorical registers. Add and subtract are
  performed by one learned table over operation, carry/borrow, left digit, and
  right digit. Its complete basis has 2 x 2 x 10 x 10 = 400 contexts and 20
  digit/carry outputs. Move, merge, swap, and queries compose those local
  transitions without generating intermediate text.
- This is a narrow neuro-symbolic executor experiment. A pass would show that
  a tiny frozen LM can compile paraphrased language into an exact reusable
  internal program when lexical number extraction and an execution substrate
  are supplied. It would not show broad language reasoning or autonomous
  algorithm discovery.

### Locked Admission And Causal Gates

The immutable training source is the 96,000-row latent-operator answer-only
corpus at depths one through four. The evaluation board contains 896 disjoint
cases: fit-IID, depth-only OOD at depths 5/6/8, language-only OOD, and full OOD
with new language, labels, numeric range, and depth. Before H100 use, a CPU
admission independently replays every structured program, checks lexical and
structured values agree, rejects every negative or eight-digit-overflowing
intermediate register, proves the oracle answer, and binds train, evaluation,
and tokenizer hashes.

Advancement requires every condition below:

1. The learned local transition table is exactly 400/400.
2. Answer accuracy is at least 70% fit-IID, 60% depth OOD, 50% language OOD,
   and 40% full OOD.
3. At least 50% of complete operation-plus-query programs are exactly right.
4. Answer accuracy exceeds a depth-matched shuffled-program intervention by at
   least 20 percentage points.
5. Oracle programs execute to the gold answer on 100% of the board.

Passing these gates permits only an output decoder bridge and fresh manual
interaction. Failure is decomposed into semantic compilation, query binding,
local arithmetic, depth composition, or causal-program sensitivity. It does
not authorize scaling an answer-only recurrent adapter or changing the
protected flagship.

### R1 Result: 2026-07-14 13:22 EDT

The compiler, categorical executor, trainer, evaluator, admission audit, and
Slurm wrappers passed their mechanical gates. CPU admission `738772` checked
96,000 train and 896 evaluation rows, all 400 local arithmetic contexts, every
intermediate register, and every oracle answer. Its report SHA-256 is
`893386103c2484308769e24ab94001d5b6026a38095d038bf8e42ccc6a841fa2`.

H100 `688994` trained a 225,742-parameter compiler/table from immutable 200k on
32,768 examples and 2,048 updates; no base parameter was trainable. Read-only
evaluation `688995` provides a split result:

- fit-IID: 251/256 answers and 250/256 exact programs;
- depth-5/6/8 OOD under training language: 155/192 answers and 150/192 exact
  programs;
- unseen language at training depths: 19/256 answers and 8/256 exact programs;
- full unseen language/range/depth: 1/192 answers and 0 exact programs;
- overall: 426/896 answers versus 45/896 after depth-matched program shuffling.

The result is real but narrow. Categorical execution avoids the recurrent
text-state decay and composes programs past training depth. The 42.5-point
answer margin over shuffled programs shows that the compiled program is
causal. Yet the operation/query compiler is surface-bound: held-out synonyms
map systematically to trained but wrong opcodes, and unseen query wording
often defaults to register 1. Four locked gates fail, including language and
full OOD, so no decoder bridge is authorized.

The next admissible test is **Paired Semantic-Equivalence Compilation**. It
must render the same structured program through two training-only paraphrase
and entity-label views, train on both, and explicitly align corresponding
operation/query distributions. Held-out words, templates, and domains remain
untouched. This isolates whether the frozen base contains enough semantic
geometry for a small head to learn an equivalence quotient. Merely adding the
held-out templates would be leakage and is forbidden. A matched classification
arm without the equivalence loss is required before attributing any gain to
the new constraint.

### R2 Locked Protocol

R2 begins from 48,000 immutable structured programs and renders two views of
each. The views use different operation and query paraphrase families and
different entity labels, while retaining identical register-relative opcodes,
numeric operands, initial register values, query opcode, and answer. Sixteen
training-only domain vocabularies rotate through both views, preventing view
identity from being inferred from labels. The exact held-out event/query
phrases and all held-out domain labels remain excluded.

The two H100 arms must match base, data, admission report, seed, layer, hidden
width, pair order, batch size, pair count, schedule, and initial-adapter hash:

- diverse-pair control: classification plus the same 400-cell ALU basis loss,
  equivalence weight 0;
- semantic-equivalence candidate: identical objectives plus symmetric KL
  between corresponding event and query distributions, weight 0.2.

Both arms retain the r1 absolute gates. Attribution to semantic equivalence
additionally requires at least five percentage points over the control on
combined language/full answer accuracy and all-case exact-program accuracy,
while fit-IID and depth-OOD answer accuracy may regress by at most three
points. If only the control passes, the result supports language-diverse
compiler supervision but rejects the equivalence-loss claim. If neither
passes, CMB remains a same-language symbolic executor and no decoder bridge is
allowed.

Before either r2 arm trains, eight hand-authored interaction prompts are
frozen in `artifacts/evals/categorical_microcode_manual_v1.jsonl`. They cover
all nine opcodes, depths four through seven, and domains and wording absent
from both r1 and the deterministic r2 render banks. Exact-table replay is 8/8.
The same transcript inspector runs r1, the diverse-pair control, and the
equivalence candidate, reporting the full predicted program rather than only
an aggregate score. These interactions are diagnostic and cannot override the
896-case locked board.

### R2 Result: Output Equivalence Is Not Semantic Identification

R2 completed with immutable 96,000-row paired data and matched control versus
KL=0.2 arms. The control/candidate scores are respectively fit 44/256 versus
46/256, depth OOD 4/192 versus 1/192, language OOD 44/256 versus 44/256, full
OOD 9/192 versus 12/192, and exact programs 30/896 versus 30/896. Combined
language plus full answer accuracy changes only 11.83% to 12.50%. Both solve
1/8 frozen hand-authored cases, the same newsroom program. The locked
comparator rejects both absolute capability and equivalence attribution.

The negative result is mechanistically useful. Assigning two paraphrases the
same opcode labels already pushes both output distributions toward the same
one-hot target, so symmetric output KL contributes little independent
information. It does not force the trunk to separate operation kind from who
acts on whom. Replacing rather than replaying the r1 language also caused
catastrophic anchor forgetting. Yet operation-kind recognition on held-out
language increased from r1's 255/640 to about 374/640, while register and query
roles remained poor. The next intervention targets that remaining factor
rather than scaling the redundant objective.

### R3 Locked Protocol: Counterfactual Role-Equivariant Compilation

R3 is an anchor-preserving, representation-level causal test:

- Every structured program has six views: the exact r1 anchor, two disjoint
  training-only paraphrases, and an exact register-permuted version of each.
  The permutation swaps initial register values and every event/query role but
  keeps key order fixed. It is an automorphism of the two-register executor,
  so the scalar answer is preserved while every non-symmetric role label
  flips.
- The compiler predicts operation kind (add/sub/move/merge/swap) separately
  from destination register, and query kind (read/sum/difference) separately
  from selected register. Deterministic composition maps those factors back to
  the original nine opcodes and five query codes.
- Kind and role use separate learned feature projections. Each role head emits
  one signed scalar `s` and constructs logits `[s, -s]`, so negating the role
  feature implements the exact two-register `Z2` action. The candidate aligns
  kind features under register exchange and aligns role features to the
  negative of their counterfactual. This is representation-level structure,
  not the output-KL redundancy that failed in r2.
- The matched control sees all six views and all factor labels. The candidate
  sees byte-identical data/order and additionally aligns normalized event/query
  features across semantic views, preserves kind distributions under register
  permutation, and requires role distributions to swap.
- Independent CPU admission must bind source/data/evaluation/tokenizer hashes,
  prove every six-view group and permutation signature, execute every oracle
  program, reject negative/overflowing states, and find zero exact or 13-gram
  held-out-language overlap before any H100 allocation.
- Both arms retain all CMB absolute gates. Attribution requires at least five
  points over the factorized control on combined language/full answers and
  all-program exactness, with no more than three points fit/depth regression.
  The frozen eight-case manual board then remains a diagnostic gate before any
  decoder bridge.

This is not generic symbolic leakage: numbers and line boundaries remain the
same disclosed deterministic frontend as r1, but operation kind and argument
binding remain neural. A pass would establish narrow language-to-program
equivariance, not broad autonomous reasoning.

The treatment strength is frozen before the full fits: semantic feature
alignment weight **0.5** and permutation-equivariance weight **1.0** for the
candidate, versus **0/0** for the matched control. Both use 48,000 complete
six-view groups, batch four groups, exactly 12,000 updates, seed 20260714, and
the same initial adapter hash. The 64-group mechanics canary established finite
losses and gradients for the superseded output-logit implementation only; it
did not tune these weights against capability. The signed-feature revision
must pass a new isolated mechanics canary before either full arm starts.

The first full construction is preserved as a rejected admission result.
Although its automorphisms, executor replay, width, and held-out-language tests
were clean, it contained 988 duplicate normalized questions and three exact
fit-IID prompts. The corrected construction never edits a rendered row. It
scans the larger immutable source in order and admits a whole six-view group
only when every rendered question is unique within the group, disjoint from
previously selected groups, and not an exact held-out prompt. Its build report
binds the selected source-index sequence and skip counts. Training remains
blocked until the rebuilt 288,000-row artifact passes every independent gate.

The corrected build selected 48,000 groups from 48,372 source rows and passed
the structural, automorphism, oracle, uniqueness, exact-prompt, held-out
language, and public-evaluation gates. A regime-aware scanner then observed
95,972 allowed anchor-boilerplate overlaps and zero forbidden rows, but its
first version incorrectly required all 96,000 anchors to overlap. The 28 clean
anchors were ordinary orchard examples with no shared 13-gram. The repaired
logic still requires exactly two anchor rows per program, permits overlap only
from anchors against fit/depth diagnostics, and rejects every exact prompt or
language/full/manual overlap; it no longer treats absence of overlap as an
error. The immutable data SHA-256 is
`9f97e9339f665de27d99195d5b4f61c8c09681ea268cd4459a5e212b8875267f`.

The corrected full-text and response-contract pass is complete. A fresh
signed-feature mechanics canary then trained 64 groups for 16 updates with a
frozen base and finite gradients. Its initial semantic/permutation losses were
0.0999/1.8672, confirming that the representation-level counterfactual term is
not the near-zero redundant logit term it replaced. The matched full control
and candidate are jobs `689070` and `689071`.

### R3 Result: Local Equivariance Is Not Referential Binding

Both arms completed their locked 12,000-update schedules and all read-only
evaluations. Control/candidate results are:

| Slice | Control answers | Candidate answers | Control exact programs | Candidate exact programs |
|---|---:|---:|---:|---:|
| fit IID | 256/256 | 251/256 | 255/256 | 250/256 |
| depth OOD | 166/192 | 167/192 | 160/192 | 160/192 |
| language OOD | 52/256 | 60/256 | 17/256 | 32/256 |
| full OOD | 20/192 | 19/192 | 3/192 | 3/192 |
| all | 494/896 | 497/896 | 435/896 | 445/896 |

The candidate therefore gains only **1.56 percentage points** on the locked
language+full answer aggregate and **1.12 points** on all-program exactness.
Both are below the preregistered five-point attribution gates, both absolute
language/full gates fail, and both frozen eight-case direct interactions are
0/8 answers and 0/8 exact programs. Comparator `738798` correctly records
`reject_role_equivariant_compiler_r3`; no decoder bridge is authorized.

The component errors are more informative than the aggregate. On language
OOD, signed equivariance improves operation-kind accuracy from 69.22% to
79.69%, query-kind accuracy from 45.31% to 66.41%, and joint non-sum query
role accuracy from 2.91% to 25.58%. It does **not** improve operation role
given the right kind: 55.70% control versus 55.61% candidate. Merge remains
nearly unreadable at 7/119 correct kinds, while the move kind rises from
43/122 to 116/122. Full-OOD local factors improve but exact programs do not;
both arms are 0/64 exact at depth 8. The candidate repairs some semantic
categories and query geometry, but each unresolved role or kind error poisons
the deterministic execution chain.

This rejects the hypothesis that stronger role-equivariance pressure alone is
the missing mechanism. The role bit is currently an absolute class predicted
from a line-ending hidden state. Unseen entity names require a *relational
identity match* between the introduction, each event, and the final query;
class-level antisymmetry cannot manufacture that match. The next mechanism
must bind dynamic entities before it classifies operations, and it must expose
enough redundant evidence that one local mistake does not destroy an entire
program.

### R4 Hypothesis: Binding-First Referential Slot Compilation

The next bounded architecture candidate is a two-slot referential compiler,
not a larger loss coefficient or another output agreement term:

1. A small token-level tagger, supervised only during training, identifies the
   two entity mentions in the introductory clause and their later mentions.
   At evaluation it receives question text only; structured keys may score the
   tagger but may never be supplied as input features.
2. Two dynamic slot vectors are pooled from the predicted introductory
   mentions. Event/query role logits are pointer similarities to those slots,
   not fixed `role_0`/`role_1` classifiers. Swapping the two slots therefore
   swaps roles by construction.
3. Operation/query kind is read from token-span attention after projecting out
   slot identity. This directly targets the observed move/merge confusion and
   avoids relying on one punctuation-position hidden state.
4. Training uses complete entity-renaming orbits, including nonce labels, so
   lexical familiarity cannot identify a register. A matched control gets the
   same token encoder, parameters, examples, and update budget but replaces
   pointer binding with an equally sized absolute-role head.
5. Held-out scoring keeps the existing 896-case and eight-case boards and adds
   tagger, pointer, and depth-conditioned exactness diagnostics. Decoder-bridge
   authorization remains the original absolute gates plus a matched gain; no
   component score alone can promote it.

This is a new causal claim: dynamic slot identity, rather than stronger
surface invariance, should make role transport survive unseen nouns and
templates. It should first be implemented and falsified on a CPU mechanics
smoke and tiny isolated H100 canary before any full matched fit.

The text-only mechanics are now implemented. Intro slots and per-line target
mentions are soft attention distributions over token spans. Mention labels
supervise those distributions during training, but `classify_text` has no key
or target-label input. Role-pointer logits compare a projected raw-token
identity pooled from the predicted target to identities pooled from the two
predicted intro slots. The matched absolute-role control instantiates the same
modules and parameter count and receives the same mention supervision, but its
role logits come from the selected contextual mention rather than a slot
identity match. This separates relational reference from extra span capacity.

Stokes job `738806` admitted the complete existing frozen substrate: 288,000
training rows, 896 held-out rows, and eight manual rows, with zero mention
alignment or structural failures. The admission binds train/eval/manual and
tokenizer hashes and records 581,562 role-bearing training operations plus
192,774 role-bearing training queries. Its SHA-256 is
`c9758c191d6dc0754547c14ad554a7479cc5375f25e6259e9eefa409f30847fc`.
The full comparison is preregistered before any H100 result: absolute versus
pointer, mention-loss weight 1.0, same seed/init/data/order/schedule and equal
parameter count; original absolute CMB gates; at least five points on both
language+full answers and all-program exactness; at least ten points on
language+full operation role conditioned on a correct kind; and at most three
points fit/depth regression. The 64-group pointer canary has now passed.
Isolated job `689101` completed 16 finite updates with the base frozen and
wrote a locally hash-verified, CPU-loadable adapter (SHA-256
`1867b5b7f3c25c93785e4e924d43ce68a7e6c40d544e1a3348d3d5e85ac029d2`).
Matched full jobs `689104` (absolute control) and `689105` (pointer candidate)
use 300,493 parameters each and share the same initial adapter SHA-256
`fd1d2b04607b1d0c81c12551ea9d7667b91b9260453e862370e540344619fabb`.
Both have cleared finite startup telemetry. Held-out and manual evaluations are
dependency-gated; no R4 capability or decoder-bridge conclusion exists until
the locked comparator reports.

R4 is now complete. The locked comparator formally rejects promotion because
the pointer candidate reaches only 51/192 = 26.56% full OOD, below the 40%
absolute floor. That rejection must stand. The matched intervention is still
the strongest causal component result in this program: language OOD rises
29/256 -> 139/256, full OOD 2/192 -> 51/192, all exact programs 469/896 ->
624/896, and language+full operation-role accuracy conditioned on a correct
kind rises 57.92% -> 100%. The candidate retains perfect fit/depth behavior.
Comparator SHA-256 is
`890a19c1d9eaad04b5d09b5216f2622a01036ba140c11455bc6837bc23a79d54`.

The factor record changes the mechanism diagnosis. Dynamic reference binding
is no longer hypothetical; it works. Remaining OOD error is dominated by
argument structure: 116/123 language and 206/243 full subtraction events using
the unseen construction `take ... away from` are classified as move. Both
phrases describe loss from an entity, but subtract has one entity argument and
move has a source and destination. R4's kind head pools a line independently
of that incidence graph. It therefore resolves the noun correctly and still
chooses the wrong transformation.

### Parallel Diagnostic: Exact Future-Jacobian Workspace

The 2026 Jacobian-lens result changes one measurement assumption without
changing any R4 gate. Our earlier immediate logit-lens and residual-patching
nulls do not test the paper's object: the average causal map from a source
residual to *all current and future* final-block residuals. Shohin may lack such
a map, but that must be measured rather than inferred from immediate
unembedding.

`train/jacobian_workspace.py` implements the exact row-batched estimator for
Shohin's custom transformer. At every valid target position it injects one
output-coordinate cotangent, backpropagates to selected source-layer
residuals, averages source positions, and freezes every model parameter. The
first canary is raw `best_step200000.pt`, one deterministic 48-token prompt,
source layers 5/9/13/17/21/25/28, final block target, and no weight or data
write. Its unit contract proves that one-row and four-row batching agree on a
tiny transformer, matrices are finite, transport shapes are correct, and no
model parameter receives a gradient.

Even a clean matrix is **not** a workspace result. Advancement requires: (1)
stable directions across disjoint prompt samples; (2) a mid-layer band where
future-Jacobian readouts recover unspoken intermediate concepts better than an
immediate-logit control; (3) coordinate swaps that redirect a downstream
conclusion in both directions; (4) zero/shuffled/non-Jacobian controls; and (5)
evidence that the same sparse directions support more than one operation.

The readout selection rule is frozen before its H100 run. Two disjoint
eight-document lens fits must have >=0.90 whole-matrix cosine at every fitted
layer. On the existing 896-case operator board, operation/query kind is scored
at the same line-ending residual under future-Jacobian and immediate-logit
readout. Among layers 13/17/21/25, select the layer with the largest combined
language/full MRR gain; it advances only if future MRR is >=1.25x immediate
MRR and future top-10 accuracy improves by >=10 points. The separate eight-case
manual board remains untouched for the bidirectional causal-swap test. This is
a diagnostic selection rule, not a capability metric.

If those gates and R4 binding both pass, the next architecture candidate is a
**Sparse Jacobian Recurrent Workspace**: bind text to dynamic entity slots,
write only a top-k future-verbalizable state into a recurrent workspace,
broadcast it through a shared block, and train counterfactual interruption
probes to report the hidden state without requiring visible chain-of-thought
in ordinary inference. Context scaling would retain the sparse workspace plus
source provenance across chunks while dropping raw source tokens. Normal,
zero, shuffled, concept-swap, source-dropped length, and direct transcript
controls are mandatory. This is a conditional mechanism proposal, not an
authorized fit or a reasoning claim.

#### Frozen Readout Result: Stable Map, No Semantic Workspace

The exact readout gate completed in job `689118` and **failed**. Independent
future-Jacobian fits remained highly reproducible across disjoint prompt
samples, but reproducibility did not imply semantic usefulness. The frozen
selection rule chose layer 13: on 2,304 language/full operation and query
concept targets, future-Jacobian MRR was 0.0002588 versus 0.0001535 for the
immediate-logit control (1.69x), while both had 0% top-10 and 0% top-100
accuracy. The required +10 percentage-point top-10 gain was therefore absent.
The hash-bound report is
`artifacts/diagnostics/jacobian_readout_raw200k_p16_v1.json`, SHA-256
`dd173d677748d4b08113c02c4664c4fcca533f1ab5028c77a25062b28362533e`.

This separates two claims that must not be conflated. Raw Shohin has a stable
average future-causal transport map, but the map does not expose the unspoken
operation/query concepts needed by the referential compiler. A coordinate
swap would consequently manipulate an unreadable rank-tail direction and
would not test a meaningful workspace. The preregistration therefore blocks
the swap and blocks direct use of this map in a recurrent bridge. Any next
workspace experiment must explicitly install and causally validate semantic
state; it cannot assume that raw pretraining already produced one.

### R5 Hypothesis: Future-Effect Argument Algebra

A literature check rules out a weak novelty claim. [Adaptive recurrence,
algorithmic supervision, discrete latent anchors, and explicit error
correction](https://openreview.net/forum?id=8bFgEyRLrO), [dynamic entity
memory](https://arxiv.org/abs/1708.00781), and [compositional latent
programs](https://openreview.net/forum?id=N99odDSTM7) all have direct prior
art. R5 does not claim novelty for those ingredients. Its narrower hypothesis
is that a tiny reasoner should carry a **function over future consequences**,
not an unconstrained vector or a generated rationale.

For the admitted two-register domain, every event is exactly a 3x3 homogeneous
affine operator over `[entity_0, entity_1, 1]`. Chronological matrix products
compose arbitrary event chunks, while query row operators read the final
answer. `train/future_effect_algebra.py` now proves this contract over all 896
held-out programs and proves that separately compiled chunks yield the same
operator after source text is discarded. This is exact mathematics, not a
trained-model result.

The proposed learned object combines two causal structures:

1. R4-style dynamic slots identify entity identity without absolute names.
2. A text-derived argument-incidence graph identifies which slots participate
   in each event and in what relation.
3. The event encoder emits an operator whose identity is supervised by its
   effects over multiple initial-state and future-query probes, rather than by
   a single arbitrary opcode label.
4. Operators compose associatively into a fixed-size source-droppable state.
5. Counterfactual one-argument/two-argument edits must change exactly the
   corresponding future effects; zero and shuffled operators must fail.

The existing R4 board is now development data. A post-hoc label-assisted arity
rule raises the frozen pointer result from 139 to 213/256 language and roughly
52 to 120/192 full while changing no fit/depth case. That result motivates R5
but cannot score it. Before any H100 fit, freeze a fresh lexical split and an
equal-parameter control that sees the same tokens, slots, examples, and update
budget but predicts unconstrained labels or vector state. Advancement requires
all original absolute compiler gates, a matched gain on the fresh split,
counterfactual operator necessity, associative chunk invariance, and a fresh
manual board. Passing those would establish a compact causal program state,
not broad language reasoning.

The first text-only argument-graph implementation is now frozen. For each event
line, it compares every projected token identity with the two dynamically
predicted introductory slots. A threshold of **0.80**, fixed before fresh
scoring, infers one versus two participating entities and masks operation kinds
with incompatible arity. Structured keys remain supervision/audit labels only;
inference receives token states and formatting-derived line spans. On the old
development board this changes the unchanged R4 pointer adapter to 252/256 fit,
173/192 depth, 226/256 language, 146/192 full, and 773/896 exact programs. That
is a strong engineering signal but not confirmatory evidence because R4's error
analysis selected the intervention.

The confirmatory contract was therefore committed before reading a fresh score.
The new board retains the 448 fit/depth preservation controls and replaces all
448 language/full cases with new greenhouse, depot, laboratory, and library
domains, three unseen surface forms per operation, new introductions, and new
queries. It must have zero exact or 13-gram overlap with both R4 training and
development. The same pointer adapter is evaluated twice, once raw and once
with the frozen argument graph. Advancement requires all original absolute
gates, >=70% fresh language answers, >=55% fresh long-composition answers,
>=15 percentage points fresh answer gain, >=10 points fresh exact-program gain,
>=95% fresh arity accuracy, complete five-operation/three-query coverage, and
no more than 10 points fit/depth regression. These are intentionally difficult:
a failure closes this parser intervention instead of inviting threshold tuning.

Even a pass authorizes only the next matched mechanism test. That test will
replace arbitrary event-label prediction with **future-effect identification**:
two text encoders must be compared under equal parameter/update/data budgets,
one emitting ordinary class/vector state and one emitting an operator selected
by its effects across counterfactual initial states and future queries. The
operator arm must additionally pass zero/shuffle necessity, argument-edit
specificity, associative chunk composition, and source-dropping transport.

The exact algebra now also has an **error-correcting future-effect code**
reference. Eight fixed counterfactual states crossed with eight future-query
probes produce 64 scalar effects for a nine-coordinate affine operator. The
valid signatures therefore occupy a strict linear subspace: projection yields
the nearest valid operator and the orthogonal residual is an explicit error
syndrome. The CPU contract recovers every clean operator, exactly corrects one
arbitrarily corrupted scalar by leave-one-measurement decoding, and preserves
chronological composition after both chunks are independently decoded. This is
not claimed as a world-first coding-theory primitive. Its research claim is
narrower and testable: a tiny language compiler may generalize better when its
hidden computation is trained as redundant observable future behavior rather
than as an arbitrary opcode or unconstrained vector.

If R5 admission passes, the matched treatment must control for redundancy as
well as parameter count. Both arms will emit the same-width code and use fixed
decoders; the treatment code consists of structured state/query effects, while
the control uses a frozen random full-rank encoding of the same operator. A
gain can then be attributed to future-effect geometry rather than extra output
channels. Numeric values must eventually be inferred from text as well; until
that separate value-binding gate passes, the experiment remains an operation-
semantics/compiler result rather than autonomous text-only execution.

#### Frozen R5 Result: Arity Transfers, Capability Does Not

The confirmatory result rejects R5. The board and both admissions passed, and
the raw/argument evaluations were concurrent on separate H100s with identical
base, pointer adapter, data, and hash-bound admissions. Raw versus argument-
constrained fresh answers are 196/448 versus 195/448; exact programs are 174/448
versus 172/448. Language changes 146/256 -> 142/256 and full changes 50/192 ->
53/192. None of the frozen gain or absolute gates passes.

This is not a failure to detect the graph. Fresh arity accuracy is 96.61%.
Instead, the graph is too coarse: only 115/408 raw operation-kind errors cross
the unary/binary partition, while 293 remain within it. The intervention changes
130 kinds, correcting 21, harming 23, and replacing one wrong kind with another
in 86 cases. At the answer level it fixes seven cases and breaks eight. Fresh
add is only 140/353 before intervention, with 99 add->subtract and 114 add->merge
errors; move has 67 move->merge and 27 move->swap errors, while swap has 99
swap->merge errors. These are different future transformations with equal or
overlapping argument incidence. Threshold tuning cannot provide the missing
semantic relation, so R5 is closed rather than rescued.

### R6 Hypothesis: Counterfactual Effect-Coded Operators

R6 is a new experiment, not a continuation that bypasses R5's failed gate. Its
premise is that a tiny compiler should identify an event by the entire function
it induces over possible states and future queries, including the event's
numeric value, instead of choosing an operation noun and receiving the value
from structured data. The current Hadamard-derived 64-effect code is exactly
conditioned: its nine operator coordinates are orthogonal, clean codes project
with zero syndrome, and one corrupted scalar is exactly recoverable in the CPU
reference. Every existing 896 program round-trips through the code and split
chunks compose after independent decode.

The confirmatory comparison must separate future-effect semantics from extra
width and coding redundancy. Treatment and control receive the same dynamic
slots, token states, parameters, output width, examples, optimizer schedule,
and update budget. The treatment uses the fixed state/query effect code; the
control uses a frozen random orthogonal 64x9 code with equal condition number
and the same decoder capacity. The R6 board must be generated only after those
arms and hashes are frozen, with unseen language, unseen numeric values,
held-out probe combinations, longer compositions, counterfactual one-event
edits, source dropping, zero/shuffled code controls, and a fresh manual
interaction. Structured operation values are forbidden at inference. A pass
would establish a narrow learned effect algebra; broad model reasoning would
still require transport into ordinary decoding and unrelated domains.

#### Pre-Fit Correction: Basis Coding Is Not the Mechanism

The random-code comparison above is superseded before any H100 fit. An exact
CPU contract now proves why: for any full-rank 64x9 treatment and control
codebooks, decoding to a common 3x3 operator and re-encoding gives a fixed
linear transport between codes. Chronological composition commutes with that
transport exactly. Equal singular values make the map an isometry on the valid
nine-dimensional subspace. A structured effect code versus random orthogonal
code is therefore a coordinate change, not a distinct reasoning mechanism.
No result from such a comparison could justify the intended causal claim.

R6 is refined to an **Active Counterfactual Distinction Loop**. A shared neural
head receives one event's text representation plus one counterfactual state and
future-query probe and predicts the resulting scalar effect. The cell maintains
a distribution over lawful event operators, selects the unobserved probe that
maximally partitions the currently plausible hypotheses, obtains one more
text-conditioned effect prediction, and repeats only while ambiguity remains.
The committed operator is then composed into a fixed 3x3 carried state and the
event text can be dropped. The internal reasoning trace is thus an auditable
sequence of questions of the form "what would this event do under this state
and future readout?", not generated prose or an arbitrary latent vector.

The exact oracle mechanics cover 597 distinct hypotheses: six numeric operator
families over values 1--99 plus three structural operators. The active policy
identifies every operator in at most three probes, averaging 1.838. A
deterministic random-probe policy also eventually identifies every operator but
averages 2.822 and requires as many as 13 probes. This is only a decision-tree
upper bound; it does not show that Shohin can answer a selected counterfactual
from text.

The neural causal test will therefore train one probe-conditioned effect head,
not two code-basis heads. Read-only inference compares active and random probe
schedulers on the byte-identical model with the same maximum number of probe
calls. A one-pass pointer compiler, zeroed effects, shuffled predicted effects,
and oracle effects are required controls. The board remains frozen only after
the head, scheduler, numeric range, tolerance, maximum latent steps, hashes,
and value/language/composition splits are fixed. Advancement requires unseen
values and language, counterfactual edit specificity, longer source-dropped
composition, a material active-over-random gain, and direct transcript evidence.
This makes adaptive future distinction operational while avoiding a basis-
renaming result.

The first isolated CUDA mechanics canary is clean. Job `689183` initialized
from the immutable raw-200k checkpoint and the frozen R4 pointer adapter,
compiled the complete admitted 288,000-row substrate, then ran 16 updates over
64 groups. It reports 466,894 trainable adapter parameters, zero trainable base
parameters, finite effect loss 0.0526 at step zero, inherited operation kind and
role accuracy 1.0 on the canary sample, and a finite pre-clip gradient norm
9.881 under the locked 1.0 clip. Training took 13 seconds after preprocessing
and the saved adapter is CPU-loadable, finite, contains no base-model tensors,
and hash-matches Newton/local at SHA-256
`b27805f489cd39069c5d3b919d113d38d2441b27f63ac70ba4d4c0187724a929`.
This certifies mechanics only; a longer development fit must show that effect
loss and gradient norms settle before any fresh-board generation.

The old-board development decision is executable and frozen before its score.
`train/evaluate_future_effect_r6.py` separates the 448 fresh language/full cases
from 448 pinned fit/depth controls. Authorization to generate one untouched R6
board requires, simultaneously: active >=55% fresh answers, >=50% fresh exact
programs, and >=65% operation recovery; >=60% language and >=40% full answers;
>=80% fit and >=60% depth preservation; at least +10 points over the unchanged
R5 raw fresh answer and exact-program counts; at least +5 points answers/exact
and operations over random with equal calls; at least +10 points
answers/exact over the better zero/shuffled control; >=80% oracle answers and
exact programs; >=95% query accuracy; and finite held-out-probe MSE no greater
than max(2x train MSE, 1.0). Any failed conjunct closes this R6 head before a
fresh board exists.

An exact pre-score board audit also bounds the runtime scheduler itself. Using
true event effects but the evaluator's actual three-step top-64 approximation,
fresh language/full reaches 382/448 answers (85.27%) and 365/448 exact programs
(81.47%). The frozen >=80% oracle floors are therefore attainable but close to
the mechanism's current ceiling. This prevents a learned head from being judged
against 100% while also preventing a weak compiler ceiling from excusing it.

A separate **R6b posterior scheduler** is frozen before any R6a learned output
is read. It does not change or rescue the R6a decision. Instead of discarding
all but a hard top-64 list after each noisy effect, it retains a Gaussian score
posterior over all 597 operators and selects the next probe by maximum weighted
partition entropy. Its assumed effect-noise scale is fixed at 1.0 and its effect
bin width at 2.0. Under deterministic equal-noise CPU mechanics, three posterior
probes recover 100% of operators with exact effects and 92.46% at noise 0.5,
versus 88.27% for R6a's hard top-64 scheduler. The implementation is
`train/future_posterior_distinction.py`.

R6a must be scored and recorded first under its existing gate. R6b may then be
run read-only on the byte-identical adapter and old development board only; it
receives the same three scalar-effect calls and must face the same random,
zero, shuffled, absolute-capability, and held-out-fidelity gates. It cannot
advance a fresh board unless its policy and comparator are frozen independently
before that evaluation. This separation prevents a stronger inference rule
from being used as a post-hoc relabeling of R6a.

#### Conditional Context Extension: Distinction-Certified Context Folding

A bounded literature search finds important adjacent work. [UNComp](https://openreview.net/forum?id=28oMPC5bcE)
uses uncertainty to vary hidden-state and KV-cache compression; [Compile to
Compress](https://openreview.net/forum?id=NjbMkeaOKD) uses compiler failure modes
to compress theorem-proving search history; [Proof-Carrying
Numbers](https://openreview.net/forum?id=455AaEhQbu) fail-closes numeric display
through external verification; and [Selection-Inference](https://arxiv.org/abs/2205.09712)
alternates model-generated natural-language selection and inference. These block
novelty claims for uncertainty-aware compression, verifier-backed outputs, or
alternating selection alone. The bounded search did not find their exact
combination with a learned scalar counterfactual-effect interface, active
posterior operator distinction, independent unused-probe certification, and
associative source-dropped operator folding. That absence is not proof of
world-first novelty; the causal mechanism and empirical result remain the claim.

If and only if the learned active policy clears its frozen active-over-random
and causal-control gates, the same mechanism has a non-token context extension.
An event may leave context only when its selected counterfactual observations
reduce the lawful hypothesis set to one operator and a separately predicted,
previously unused probe agrees with that operator. The accepted event operator
then composes into a fixed 3x3 chronological state. Ambiguous or independently
inconsistent events retain their source instead of being silently compressed.

The exact CPU reference in `train/counterfactual_context_folding.py` admits all
597 oracle event certificates using at most three selected probes plus one
independent validation probe. It folds 4,096 chronological events, discards all
event sources, and retains the same nine-scalar operator and answers as direct
execution. Independently folded chunks merge associatively. Empty evidence is
rejected as ambiguous and a corrupted validation effect is rejected before
folding.

This is a proof-carrying algebra contract, not a learned context result. It is
intentionally stronger than retaining an opaque latent or model-authored text
ledger: source deletion is conditional on a falsifiable future-effect witness.
The neural mechanism may advance only after the R6 head demonstrates calibrated
held-out-probe certificates. A context-scaling claim would additionally require
source-dropped length transfer beyond the native window, injected-certificate
corruption that causes retention or reopening, equal-model raw-context controls,
and measured retained-state, prefill, and accuracy curves. Until then the
nine-scalar result is an oracle upper bound.

#### R6 Outcome: Causal Use Without Semantic Transport

R6a is rejected before any fresh confirmatory board. Its isolated 466,894-
parameter effect adapter completed 12,000 updates and the frozen evaluator
scored 896 old-board cases under five policies with exactly three effect calls
per event. On the 448 development-fresh language/full cases, active probing
recovers 610/1,856 operations, compared with 407 for equal-call random, 78 for
shuffled effects, and 24 for zero effects. The +10.94 percentage-point operation
gain over random is real causal evidence that the selected interventions are
used. It is not reasoning evidence: active reaches only 36/448 answers and
19/448 exact programs, while learned effect MSE rises from 0.33 on fit and 0.84
on depth to about 130.74 on unseen language/full.

The failure is representational, not merely schedular. Of 1,856 active fresh
operations, 884 have the wrong opcode and another 362 have the right opcode but
the wrong value; subtraction is essentially absent. Query binding is only
342/448. R6b's stronger posterior scheduler therefore remains an unrun CPU
mechanics result: choosing a better question cannot repair an answer interface
whose unseen semantic response is off-scale. No R6 fresh board, source-drop,
context-folding, or broad capability claim is authorized.

### R7 Hypothesis: Interventional Semantic Quotients

R7 changes the observable instead of tuning R6. The central hypothesis is that
a natural-language operation can be identified by its **causal response field**
inside a frozen language model. For an unknown event, the evaluator makes
matched finite interventions to visible initial values, event values, and
entity roles, then measures how the final future-token hidden state changes at
frozen layers 5, 11, 17, 23, and 29. It constructs the same nonlinear finite-
difference signature for lawful canonical operator hypotheses. The predicted
operator is the canonical hypothesis whose intervention signature best matches
the unknown event.

This is not a learned operation classifier, a chain-of-thought prompt, a logit
lens, or R6's supervised scalar-effect head. It uses no gradients and trains no
weights. It asks whether two descriptions implement the same transformation by
comparing what the frozen network itself does under matched interventions.
The active policy spends a frozen budget of two intervention channels chosen to
maximize pairwise candidate separation. Equal-budget random-channel,
unintervened direct-hidden-similarity, and shuffled-signature policies prevent a
generic representation or extra-compute gain from being called causal
semantics.

The adjacent literature prevents an unqualified novelty claim. [CausaLM](https://arxiv.org/abs/2005.13407)
trains counterfactual representations for causal explanation; [Passive Learning
of Active Causal Strategies](https://arxiv.org/abs/2305.16183) studies learned
intervention policies; [Model-based Interactive Semantic
Parsing](https://arxiv.org/abs/1910.05389) uses a world model and clarification;
and [Selection-Inference](https://arxiv.org/abs/2205.09712) alternates language
selection and inference. A bounded search did not find the exact combination of
canonical operator hypotheses, nonlinear future-hidden finite-difference
fields, actively selected matched textual interventions, and an independent
unused-intervention certificate. That is an informed project-novelty hypothesis,
not proof that the method is world-first.

The first canary is deliberately small and read-only: exactly 108 development
events, 12 for each of nine opcodes, restricted to the already-used language and
full regimes. It uses visible identifier strings and numeric literals supplied
by the board to construct lexical candidates; therefore a pass is only a
semantic-identification canary, not a complete text-only reasoner. Before any
score is read, advancement is frozen as all of: active opcode accuracy at least
45%; active at least five points above random and direct hidden similarity;
active at least 15 points above shuffled signatures; and at least seven of nine
opcodes reaching 4/12. A pass authorizes only a full evaluation on the already-
used R5 board. It does not authorize training, fresh data, source deletion,
reasoning, or context-scaling claims. A failure closes this R7 observable rather
than triggering threshold tuning.

#### R7 Outcome: First-Order Causal Signatures Are Not the Semantic Interface

Read-only H100 canary `689233` completed all 108 events with exit 0. Active
first-order signatures score **32/108 = 29.63%**, random channels 30/108,
shuffled signatures 24/108, and unintervened direct hidden similarity 46/108.
All five frozen advancement conjuncts fail: active is below 45%, leads random by
only 1.85 points, trails direct by 12.96 points, leads shuffled by only 7.41
points, and reaches 4/12 in only four of nine opcode families. R7 is therefore
closed without a full old-board or fresh evaluation.

The failure is informative. Direct hidden similarity identifies 24/72 numeric
and 22/36 structural events. Active first-order intervention falls to 13/72
numeric while retaining 19/36 structural. It has no correct `add_1` cases and
only three correct subtraction cases across both roles. Thus the frozen model's
ordinary state contains lexical/operator information, but the first derivative
of that state under a one-token-width value or role perturbation is dominated by
generic entity structure. A stronger classifier on the R7 signatures would be
another fit, not a new mechanism.

### R8 Hypothesis: Counterfactual Curvature Binding

R8 tests whether operator semantics appears in a **mixed second-order causal
response** rather than the failed first-order direction. For two matched
interventions `i` and `j`, define a hidden-state curvature
`K(i,j) = h(i,j) - h(i) - h(j) + h(0)`. The subtraction cancels each generic
first-order replacement. What remains measures whether the model nonlinearly
binds the event value or event roles to a particular initial-state role. The
same curvature is computed for an unknown natural-language event and every
lawful canonical operator hypothesis; nearest curvature identifies the
operator without a trained classifier.

Numeric events use the two pre-score binding pairs `(event_value, initial_0)`
and `(event_value, initial_1)`. Structural events use `(event_roles, initial_0)`
and `(event_roles, initial_1)`. Equal-count random-pair and shuffled-curvature
controls, plus the already-measured direct-hidden baseline, remain mandatory.
All four variants of a pair have matched token width. This is a used-board
mechanism-development test; it cannot claim confirmation.

Before R8 scoring, advancement to one untouched confirmatory board requires all
of: curvature accuracy at least 50%; at least +7 points over the frozen R7
direct baseline and +15 points over R7 active; at least +10 points over
equal-count random pairs and +20 points over shuffled curvature; numeric
accuracy at least 40% and structural accuracy at least 65%; and at least seven
of nine opcodes reaching 5/12. Failure closes curvature binding rather than
authorizing a fitted rescue. Even a pass would establish only a read-only
operator-semantic observable. It would not establish execution, multi-step
reasoning, source deletion, or a trainable tiny-model reasoning mechanism.

#### R8 Outcome: Hidden Curvature Is Real but Not Operator-Aligned

Read-only H100 canary `689237` completed all 108 registered events with exit 0.
Counterfactual curvature scores **26/108 = 24.07%**, random pairs 28/108,
shuffled curvature 24/108, and the byte-identical direct-hidden baseline remains
46/108. Numeric curvature is exactly chance at 12/72; structural curvature is
14/36. Only two opcode families reach 5/12. Every frozen advancement condition
fails, so no untouched confirmation board is generated.

The mixed response is not numerically absent: the unknown-event curvature norm
has median 87.15 across the registered layers. It is simply not aligned with
operator identity. Curvature is uniquely correct in 15 cases but direct is
uniquely correct in 35, with only 11 shared. Therefore neither first-order nor
second-order local prompt derivatives provide the semantic execution interface
we need. More layer searches, pair searches, normalizations, or classifiers on
this same board would be post-score fitting and are not authorized.

### Architectural Direction After R8: Orbit-Consistent Recurrent Microcode

The next hypothesis must **create** a causal program substrate rather than mine
one from a next-token-pretrained representation. The development direction is a
small weight-tied recurrent microcode cell with three explicit latent objects:
an operator hypothesis, a carried state, and an independently predicted error
syndrome. Direct hidden states initialize the operator hypothesis because R7/R8
show they contain the strongest available semantic signal. Training then
enforces an orbit law: paraphrases must preserve the operator, role swaps must
permute it, value perturbations must translate it, inverse compositions must
cancel, and an unused counterfactual must predict the same committed update.

At inference the same cell is replayed, without adding parameters, until the
syndrome is below a frozen threshold or a step cap is reached. A state update is
committed only when the independent counterfactual checksum agrees; otherwise
the source remains available and the cell iterates. This gives additional test-
time computation to a tiny model while tying every latent step to an executable
causal invariant. It also supplies a future context rule: only syndrome-zero
events may fold into the associative carried state.

This is a research direction, not yet a preregistered R9 experiment. Its first
requirement is an exact CPU mechanics contract and an equivalence audit against
ordinary supervised operator classification. The experiment must include a
same-parameter classifier without orbit losses, a shuffled-orbit control, a
no-syndrome recurrent control, and fixed-step versus adaptive-step evaluation.
It may reach an H100 only if the proposed orbit and syndrome constraints are not
mathematically reducible to label augmentation or confidence thresholding.

#### R9a Outcome: Static Orbit Recurrence Is Not a New Mechanism

The pre-neural equivalence audit rejects the first formulation. With orbit-view
logits fixed during replay, the affine consensus recurrence has an exact
closed-form feed-forward expression. Across recurrence depths 1, 2, 4, 8, and
16 and update rates 0.2, 0.5, and 1.0, the largest float64 output discrepancy is
`8.881784197001252e-16` and the largest autograd discrepancy is
`2.168404344971009e-19`. Orbit-output cross-entropy is exactly ordinary
cross-entropy after transforming each view's class label. The static
Jensen-Shannon syndrome is likewise a one-shot function of the unchanged view
logits.

This closes static orbit replay, not the broader attempt to build a program
substrate. A loop becomes a candidate reasoning mechanism only if executing a
step changes the evidence available to a later step or applies noncommuting
transitions to carried state. Weight tying, more replay steps, and adaptive
thresholds alone do not meet that bar.

### R9b Hypothesis: Bidirectional Noncommutative Operator Trees

R9b changes both the evidence and the context contract. A forward compiler must
predict an event operator from the source plus its incoming carried state. A
separate backward compiler must predict the same operator from the source plus
the future query or goal propagated backward through the suffix. These are not
two heads over one pooled text embedding: the conditioning variables and
training evidence must be directionally different. Each event therefore has a
semantic syndrome given by disagreement between its complete forward and
backward affine effects.

Certified leaves compose in chronological order inside a binary product tree.
Because the affine operators are noncommutative, event order is part of the
state transition. A parent may become certified only when both children were
already certified and the two directional products agree. This inheritance law
prevents equal-and-opposite leaf mistakes from disappearing in a correct parent
product. Certified subtrees discard their source and retain one fixed-size
operator. An uncertified tree recursively opens only the failed leaves while
keeping certified sibling summaries, so later neural replay can revisit the
syndrome-localized evidence rather than re-reading the full history.

The exact CPU contract passes all frozen mechanics gates. It executes all
896/896 frozen programs exactly; distinguishes two orders of the same event
multiset with answers 7 and 10; folds 4,096 clean events to one nine-scalar
operator; and localizes a single directional error at event 2,345 while
retaining exactly one source and 12 certified sibling summaries. The resulting
frontier has 13 nodes and 109 numeric scalars. This decision is not reproducible
by a confidence threshold: matched 99.9% confidence can either agree or
disagree. The report SHA-256 is
`d9f303168d78363a780b94e203bb2435e3b1b3086d46b2c31e67d3da419a1350`.

The mechanics also expose the hard failure mode: independently named channels
that learn the same bias can agree confidently on the same wrong operator. The
neural experiment is therefore unauthorized until its preregistration freezes
all of the following:

1. Forward evidence conditioned on an incoming state and backward evidence
   conditioned on a propagated future goal, with no structured labels provided
   at inference.
2. A same-parameter single static compiler and a two-head compiler without
   syndrome-gated reopening.
3. A shuffled-backward-goal control that preserves extra compute and parameter
   count but destroys semantic direction.
4. Fixed-step versus adaptive syndrome-localized replay under an equal maximum
   compute budget.
5. An agreed-wrong stress partition measuring common-mode certification errors,
   not only directional disagreements.
6. Fresh length and language transfer, retained-source curves, and exact
   operation/program/answer gates frozen before fitting.

The bounded project-novelty hypothesis is the combination of directionally
independent state/goal compilation, inherited fail-closed certification, and
hierarchical source reopening for adaptive recurrent execution. Affine operator
composition and bidirectional processing are established ideas individually.
No world-first claim, neural reasoning claim, or context-scaling claim follows
from the current oracle mechanics.

A bounded prior-art check further narrows that boundary. Neural-guided
bidirectional program search already uses inverse semantics
([Alford et al., 2021](https://arxiv.org/abs/2110.11536)); iterative
forward-backward abstract interpretation already alternates input and output
constraints to prune synthesis
([Yoon et al., 2023](https://arxiv.org/abs/2304.10768)); neural synthesis systems
already execute and iteratively repair candidate programs
([Gupta et al., 2020](https://arxiv.org/abs/2007.08095)); and looped models
already halt on fixed-point convergence
([Movahedi et al., 2026](https://openreview.net/forum?id=8HeM93bcCq)). Verifiable
context compression also has a commitment-preservation formulation
([Trukhina and Vashkelis, 2026](https://arxiv.org/abs/2605.17304)). The bounded
search did not locate their exact combination with independently conditioned
per-event neural compilers, inherited leaf-level certification through a
noncommutative product tree, and syndrome-localized reopening of only failed
source leaves. This supports a project-novel combination hypothesis only. A
broader systematic review and positive matched neural evidence would be needed
before any publication-level novelty statement.

#### R9c Preregistration: Dynamic Directional Evidence

R9c is the first trainable formulation that clears the R9a equivalence failure.
Its forward compiler consumes an event feature, its incoming affine state, its
private recurrent memory, and the prior signed syndrome. Its backward compiler
has independent parameters and replaces incoming state with the future query
covector propagated backward through later candidate operators. Replaying the
cell changes private memory and therefore later prefix and suffix evidence.
Static conditioning, removal of syndrome, goal shuffling, fixed replay, and
adaptive replay are runtime switches over the same parameter tensors.

The untrained causal audit establishes the intended graph. The last forward
decision has nonzero gradient `5.291302579726353e-05` with respect to the first
event; the identical static mode is exactly zero. The first backward decision
has nonzero gradient `0.0003757792082463462` with respect to the last event;
static is exactly zero. Perturbing the backward compiler changes second-round
forward logits by `0.07678362727165222` when syndrome is enabled and exactly
zero when it is removed. Adaptive replay can update 15 events in round one and
zero thereafter under a certifying threshold, while fixed replay updates all 15
in every round. This proves dynamic causal paths, not useful semantics.

The language bridge reuses the admitted R4 pointer adapter because prior work
already solved dynamic entity binding. It discards R4's static opcode decision
and constructs a 521-coordinate event feature from text-derived kind/target
contexts, old kind evidence, pointer-role evidence, and slot-presence evidence.
The frozen text query head supplies a soft query covector. The production
96-coordinate private memories add 328,502 trainable parameters; every arm has
the same initialization and parameter count.

Supervision is intentionally split by causal direction. The forward arm is
trained only on each candidate operator's effect on the actual oracle prefix
state. The backward arm is trained only on the candidate's pullback of the
actual future goal. Agreement, endpoint consistency, and a small categorical
entropy term join them, but neither channel receives opcode cross-entropy. The
structured program therefore supplies training effects, never an inference
input.

Before any score is observed, the used-board canary is frozen at 4,096 semantic
groups per arm, three recurrent rounds, one H100 per isolated arm, and four
arms: treatment, static conditioning, directional conditioning without
syndrome, and treatment with shuffled goals. Advancement requires all of:

1. OOD operation accuracy at least 3 points over static, 2 over no-syndrome,
   and 5 over shuffled goals.
2. OOD answer accuracy at least 3 points over static, with language/full answer
   floors of 60% and 35%.
3. At least 95% operation accuracy on fit/depth preservation regimes and 98%
   query accuracy.
4. Agreed-wrong operations no more than 50% of all wrong operations.
5. Syndrome-adaptive replay within one point of fixed-replay OOD operation
   accuracy while using at most 80% as many event updates.

Failure rejects this R9c formulation without threshold tuning. Passing
authorizes only a full matched-arm fit followed by one untouched confirmation
board. It cannot establish broad reasoning, internal decoder thinking, or
context scaling until learned certificates correctly govern source folding and
reopening on lengths beyond the native context.

#### R9c Outcome: Dynamic Causal Paths Are Not Sufficient

R9c is rejected by its preregistered used-board gate. The corrected neural fits
used four exactly matched arms with the same initial adapter hash, 328,502
trainable parameters, 4,092 selected semantic groups, 24,552 text examples,
1,023 updates, and immutable base, pointer, tokenizer, and data hashes. Eight
dependency-held evaluations and one CPU-only assessor completed without a
contract error.

On the fresh OOD board, treatment operation and answer accuracy are 78.29% and
47.77%. Static conditioning reaches 80.12% and 51.12%; directional conditioning
without syndrome reaches 81.14% and 51.79%; treatment with shuffled future goals
reaches 79.58% and 50.89%. Treatment also misses the 35% full-OOD answer floor at
30.21%, while 88.83% of its wrong operations are common-mode errors on which both
directional channels agree. Adaptive replay preserves treatment accuracy while
reducing mean event updates from 3.0 to 1.62, but that efficiency does not rescue
an inferior learned operator.

This separates a necessary mechanism property from a sufficient one. R9c's
untrained graph genuinely contained cross-event, future-goal, and cross-channel
causal paths; nevertheless, supervised optimization converged to nearly the same
local event classifier in every arm. The syndrome transported disagreement, not
independent semantic evidence, so shared bias remained invisible. The shuffled-
goal control outperforming treatment further shows that useful backward goal
semantics were not learned. Future work must create an observable that one
direction cannot reconstruct from the other direction's local text evidence,
and must causally require that observable on transfer examples. Adding more
rounds, widening memory, or relaxing the frozen thresholds is not an R9c repair.

The canonical decision is
`artifacts/eval_history/r9c_used_board_decision_r2.json`, SHA-256
`cb3013800daaeb95b0bc8b2d454b89cf177a4e2dc652633eb0392a625a87b012`.

A post-result identifiability audit closes the certificate more strongly. The
eight-dimensional categorical probability simplex projects into an affine
operator family of affine rank five. Two strictly positive distributions with
different argmax operations (`add_0` and `move_1_0`) have the same exact
expected operator to `1.1102230246251565e-16`. R9c's runtime float32 probability
cast leaves a syndrome norm of only `2.2130991894593727e-08`, still far below
the frozen `0.05` halt threshold. Expected-operator agreement is therefore not
injective with respect to the categorical decision that the evaluator executes.

The original shuffled-goal arm also does not support a strong semantic-goal
attribution. Six equivalent views are adjacent in every selected group, so a
one-position batch roll sends five of six examples a goal from the same
equivalence group. The static and no-syndrome losses remain valid negative
comparators and already reject treatment, but the shuffled-goal margin must not
be interpreted as a clean future-semantics intervention. The exact regression
audit is `train/audit_bidirectional_syndrome_identifiability.py`; report SHA-256
is `9c54c1cf498804056aa34b5b5b1d7b78a4c181a69c8b9b7a77904cfb816f1777`.

This eliminates a point-distribution syndrome as the next interface. A future
certificate must preserve the **set** of lawful exact transforms still
consistent with text evidence and compose that set without pruning. Agreement
on one current query may authorize a selective answer but cannot authorize
irreversible deletion. Even a singleton is conditional on candidate-set
coverage, so compressed source must retain a retrieval pointer unless semantic
completeness is established independently.

### R10 Preregistration: Annihilator-Certified Ambiguity Workspace

R10 does not replace one point estimate with another. It carries uncertainty
through execution and permits commitment only when the remaining uncertainty is
provably irrelevant to the requested read. The exact reference implementation
is a version-space product tree (VSPT): each event owns a finite set of lawful
3x3 affine transforms, internal nodes compose every chronological product, and
identical transforms are deduplicated without score-based pruning. A node that
would exceed 32 exact transforms overflows fail-closed: it retains its source,
emits no certificate, and cannot be counted as context compression.

VSPT is a diagnostic oracle, not the novelty claim. Version-space algebra and
automata representations of program sets are established
([Lau et al., 2003](https://homes.cs.washington.edu/~pedrod/papers/kcap03b.pdf);
[Wang et al., 2021](https://arxiv.org/abs/2107.12568)), and recent
neurosymbolic synthesis already uses calibrated candidate sets and active
disambiguation
([Barnaby et al., 2025](https://arxiv.org/abs/2508.15750)). Calibrated semantic
interpretation is also established
([Stengel-Eskin and Van Durme, 2023](https://arxiv.org/abs/2211.07443)). R10's
bounded project-novel hypothesis is the combination of a neural compiler with
an exact noncommutative product tree, a sound affine ambiguity quotient,
query-annihilator certificates, and witness-localized reopening for context
management. No world-first statement is authorized without a broader review
and positive untouched-board evidence.

The proposed **Annihilator-Certified Ambiguity Workspace (ACAW)** compresses an
exact transform set into a sound affine hull `A0 + span(U1, ..., Ur)`.

For chronological composition of an earlier hull `A0 + U` and a later hull
`B0 + V`, the child product is overapproximated by an anchor `B0 A0` and the
span of all `B0 Ui`, `Vj A0`, and `Vj Ui` terms. Exact rank reduction follows
each product. Homogeneous 2D affine differences have a zero bottom row, so the
ambiguity rank cannot exceed six; a larger rank is a contract failure. The hull may add impossible transforms and therefore reduce coverage,
but it must never remove a lawful transform or create false certainty.

For initial homogeneous state `s` and query covector `g`, ACAW may certify the
current scalar answer only when `g Ui s = 0` for every ambiguity basis element.
This is the annihilator condition: all transforms in the sound hull give the
same current answer. That certificate does **not** authorize general source
deletion: a later continuation can rotate a currently invisible ambiguity into
the query. Rank zero authorizes only **candidate-conditional hot-context
eviction**, backed by an immutable retrieval pointer. Irreversible source
deletion is forbidden in R10. Nonzero-rank nodes retain every unresolved leaf;
rank-zero siblings remain exact summaries. Adaptive computation may refine one
leaf only by a monotone candidate-set reduction and must then recompute the
exact product-tree path to the root. Selection uses exact leaf interventions,
not basis-vector magnitude, because bilinear cross-terms can make two leaves
jointly observable. This is the context-scaling hypothesis under test: fixed-
dimensional **certificate** state, exact factorized subtree provenance, and
retrieval-backed reopening without putting certified source back into the hot
token window. It is not a constant-memory replay claim: worst-case unresolved
provenance remains linear in history length.

The affine hull is never treated as replay provenance. Every leaf candidate has
a stable atom identity, exact transform, source hash, and replayable external
reference. Every internal node retains its two child commitments and exact
transform set while under the cap. A leaf-local monotone refinement rebuilds
all Cartesian child products on its root path, costing `O(K^2 log n)` for cap
`K=32`. Overflow retains its factorized children and emits no certificate; it
does not resurrect hot source already represented by an exact singleton
sibling. A self-contained flattened node would require the complete derivation
circuit for every transform, not one canonical witness. Global evidence,
candidate additions, or cross-leaf constraints fail closed and force broader
reconstruction. Active token bytes, factorized provenance bytes, external
source bytes, and reread bytes are reported separately.

The executable reference does not store flattened opcode witnesses. Each leaf
atom is SHA-256 committed; aliases of the same exact transform commit to every
supporting atom; and each internal transform commits to every supporting child
pair. The exact child topology remains the replay authority, so a commitment is
an integrity binding rather than a substitute for alternate derivations. Raw
source references live only at leaves, not duplicated in every ancestor. A
singleton compact-frontier record contains the exact transform, fixed-size
support and node commitments, and a contiguous `(start, end)` external
retrieval reference. This removes the accidental linear witness and
`O(n log n)` duplicated source tuples from the reference representation. It
does not change the lower bound: the retained factorized tree and external
source store are still linear in unresolved history in the worst case.

#### Frozen Score Provider And Board

The only neural score provider is the strongest already-frozen R9c arm,
`train/r9c_no_syndrome_200k_canary_r2/syndrome_adapter_ep1.pt`, SHA-256
`bf07d65075a42142c34bfc510cbef95290a9b8a0f7ed96ac1d4abc5f175a6480`.
It is read-only. R10 may not retrain it, tune its logits, search layers, or
change its text bridge.

The old development board is
`artifacts/evals/referential_argument_graph_v5_fresh.jsonl`, SHA-256
`d85f16ff374b0c650cf3603826cc5f3b377842818db62bada3b84e71308b9473`.
Its structural admission and label admission must both remain true; their file
SHA-256 values are respectively
`4a24a6999ae43d433d44fc24f25bc13ce60b4ab1856094dcdfd7b24a776abfd2`
and `a93f1b2623e8962efbd63541ad1a79694a8fb3f2e7c8aa1931c0b55faa786699`.
Because `no_syndrome` was selected as the strongest R9c arm using this exact
board, it is exploratory and kill-only for R10. It cannot calibrate or authorize
a positive result. Before any score extraction, a model-unseen calibration
board and separate confirmation board must be generated, independently audited,
hash-frozen here, and kept score-blind. The confirmation board contains at
least 1,024 programs balanced across lengths 4, 8, 16, and 32 so that 40%
coverage can yield more than 300 accepted cases.

For each calibration **program**, nonconformity is the maximum of
`-log p(true_operation)` over all events and `-log p(true_query)`. At target
program coverage 97%, the threshold is the `k`th sorted program score with
`k = ceil((n_programs + 1) * 0.97)`; if `k > n_programs`, the threshold is
infinity. Each event candidate set contains every operation whose probability
is at least `exp(-threshold)`, and the query candidate set follows the same
rule. There is one global threshold. Per-event calibration would compound its
error across long programs and is forbidden, as are per-family, per-length,
and post-result threshold selection.

The extractor must bind the base, adapter, tokenizer, board, both admissions,
code revision, seed, complete per-event categorical distributions, and the
complete query distribution into one machine-readable report. No evaluation
may start from a missing or mismatched hash. The exact VSPT, point-argmax
execution, shuffled candidate sets, and oracle candidate sets are reported
controls. Candidate sets are composed using exact integer/rational affine
effects; floating matrix equality is not a certificate. Opcode candidates
include role binding. Numeric values and event order remain deterministic text-
extraction contracts, not model predictions: the bridge directly receives the
lexically extracted initial and event-value slots after admission verifies them
against structured metadata. Parsed-slot and oracle-structured controls must be
named separately. R10 is therefore an external neuro-symbolic execution test,
not evidence that Shohin internally thinks.

#### Frozen Mechanics Gates

Before neural scores can decide anything, the CPU reference and ACAW must pass
all of the following:

1. Exact VSPT composition matches exhaustive enumeration on every tested small
   program, preserves event order, and has zero false answer or hot-eviction
   certificates under injected ambiguity and overflow.
2. Every exact VSPT transform is contained in ACAW's affine hull after every
   leaf and internal product; every ambiguity direction has a zero bottom row
   and rank never exceeds six.
3. ACAW has zero false query certificates against exhaustive VSPT. It may
   abstain where VSPT answers, but it may never certify a different answer.
4. Rank-zero candidate-conditional hot eviction has zero false evictions
   against the known oracle. Query-only agreement never increments hot source
   removal, and irreversible source deletion remains exactly zero.
5. A query intervention that changes which ambiguity directions matter must
   change or revoke the certificate on the corresponding constructed cases.
6. A monotone leaf refinement followed by path-to-root recomputation must
   produce the same exact version space, all-support commitments, and overflow
   state as full replay under the same evidence. A failed match rejects
   adaptive context scaling even if answer accuracy is high.
7. The indistinguishable-root counterexample with left/right candidate sets
   `{I,S}/{I,S}` versus `{I}/{I,S}` must diverge correctly after the right leaf
   is fixed to `I`. Removing one canonical derivation must not remove a
   transform supported by another derivation.
8. Serialized singleton summaries contain no raw source and no linear-length
   opcode witness. Overflow preserves factorized child state without emitting
   a certificate. Candidate additions and non-local evidence are rejected.

#### Frozen Used-Board Gates

All gates are conjunctive and evaluated separately where stated:

1. True-operation event coverage and true-query coverage are each at least 97%
   on `language_ood` and `full_ood`; complete-program candidate coverage is at
   least 95% on each partition.
2. Selective answer accuracy is at least 99% at at least 40% program coverage
   independently on every confirmation partition. Every depth and query stratum
   has at least 25% selective coverage; no partition may subsidize another.
3. There are zero false full-transform certificates and zero false hot-context
   evictions against known truth. Query certificates are counted separately,
   every eviction retains a retrieval pointer, and irreversible deletion is
   zero by construction.
4. Root-size statistics encode overflow as 33: p50 is at most 16, p90 is at
   most 32, and total overflow is at most 10%. Uncapped exact root size is also
   reported wherever feasible; a non-overflow size-at-cap gate is forbidden as
   tautological.
5. ACAW preserves zero false certificates and never reports higher certified
   coverage than exact VSPT on a case that its hull does not prove.
6. At exactly ACAW's accepted count within each partition, its observed
   selective accuracy exceeds the best of frozen max-probability, minimum-
   margin, and entropy abstention baselines by at least one percentage point.
   Since every nonempty candidate set contains top-1, ACAW is an abstention
   mechanism on this board and cannot claim to correct accepted top-1 answers.
7. Hot-context reduction is computed over every original event in a disjoint
   root compact frontier, not only convenient certified subtrees. Canonical
   serialized hot bytes, factorized-provenance bytes, external-source bytes,
   retrieval count, and runtime are reported separately by length and accepted
   status. Integer/rational bit growth counts toward memory.

Failure closes this frozen score-provider path. There is no threshold, cap, or
rank rescue. The old board can only reject. The new calibration board fixes one
threshold; the already-frozen confirmation board then decides. Confirmation
must reach the gates above, include at least 300 zero-error accepted cases
before a 99% population-reliability statement is even considered, and achieve
at least 75% retrieval-backed hot-source removal over all events with zero false
hot evictions. No localized learned replay claim is available in R10 because a
non-oracle second evidence source has not yet been frozen. A static pass could
authorize a separate preregistration for that re-reader; it cannot establish
broad language reasoning, internal thinking, or safe irreversible deletion.

#### R10 v2 Finite-Board And Custody Amendment

This amendment supersedes every conflicting R10 clause above before any R10
probability was extracted. In particular, R10 makes **no population-reliability,
simultaneous-confidence, Clopper-Pearson, Bonferroni, target-success-probability,
or future-sample claim**. Calibration and confirmation are finite deterministic
boards. Passing can describe only observed behavior of the one frozen score
provider on those exact admitted rows.

The canonical board contract is exactly:

- calibration seed `2026071401`, exactly 800 rows, 80 exact
  operation/query/depth cells, and exactly 10 rows per cell;
- confirmation seed `2026071402`, exactly 1,840 rows, split into exactly 920
  `language_ood` and 920 `full_ood` rows;
- each confirmation partition has exactly 40 operation/query/depth cells and
  exactly 23 rows per exact cell;
- every exact confirmation cell must accept at least 10 rows, every partition
  at least 400 rows, and every cell and partition must have zero false
  certificates;
- observed selective accuracy is at least 99% in each confirmation partition;
  family, query, depth, and partition results are reported separately and may
  not subsidize one another.

The only novelty source is the already-frozen R5 board SHA-256
`d85f16ff374b0c650cf3603826cc5f3b377842818db62bada3b84e71308b9473`.
Counts, seeds, and that hash are code constants, not runtime choices. Any other
seed, count, novelty source, or regenerated board is a different experiment
and cannot inherit R10.

A score-blind board gate is valid only when one exact committed source checkout
independently regenerates or verifies the build manifest, structural and label
admissions, board hashes, frozen code/runtime closure, and every finite-board
cell. Boolean fields such as `all_checks_pass` are never evidence by themselves.
The exact committed identity must be equal before and after admission, and a
dirty, untracked, mutable, or revision-mismatched runtime tree fails closed.

Probability extraction and the CPU decision form one frozen execution chain.
No operator-supplied, rehashed score JSON may become decision input. Every
artifact is loaded from one immutable byte snapshot, hashed and parsed from
those same bytes, and either held through the decision or revalidated before
atomic publication. The gate freezes batch size, deterministic-algorithm
settings, Python/PyTorch/tokenizer/CUDA runtime identity, device identity,
board name, seed, exact output namespace, and one allowed calibration plus one
allowed confirmation invocation. A second output path, batch, runtime, device,
seed, or report is not an R10 replicate and cannot be selected.

Independent review found the pre-amendment implementation did not yet enforce
all of this: self-attesting manifests, job-only clean-code checks, seed/input
shopping, score substitution, TOCTOU, incomplete replay identity, and source
mutation during admission were possible. That implementation is therefore
NO-GO even though its mechanics tests passed. No R10 neural probability tensor
was read. A new implementation must add adversarial regression tests for each
attack and survive another independent review before any Stokes build or score
access.

## R12: Mathematical Invention Before Architecture

The user has superseded architecture-first reasoning work. The detailed contract
is frozen in `R12_REASONING_INVENTION_CHARTER.md`. R9, R10, and R11 remain
negative evidence and matched controls; they are not templates to tune or rename.

The first mathematical result is a no-go boundary: fixed context, finite
precision, and bounded runtime make every deterministic classical mechanism
extensionally equivalent to a finite acyclic circuit after unrolling and
inlining. An absolute claim of non-equivalence to every static classifier is
therefore impossible. R12 instead requires a uniform asymptotic family and an
explicit resource-bounded comparator.

The operational target is uniform late-query causal composition. Histories are
equivalent only when every admissible continuation and every withheld query
produce the same answer relation. The required abstract state is the
counterfactual residual `rho_h(c, q) = R(hc, q)`, updated by residual derivatives
that satisfy closure, composition, observation, extensionality, separation, and
uniformity. If the causal quotient has `N` states, an exact query-oblivious state
needs at least `log2(N)` history-dependent bits.

The first theorem-backed witness uses adjacent transpositions and a late query
for the image of one object. Once all permutations are reachable, the causal
quotient contains exactly `m!` states. Its `m=2` restriction is parity and thus
separates the target from polynomial-size constant-depth AND/OR/NOT circuits.
This is deliberately not presented as a separation from arbitrary transformers
or threshold circuits; the relevant stronger complexity separation is open.

Architecture proposals based on path-ordered products, persistent product
trees, or gauge-reduced Schur boundary actions were independently derived and
rejected as inventions: they reduce to recurrence/fast weights or known dynamic
data structures and differentiable algebra. They remain useful favorable
controls. No R12 code, board, training data, fit, score, or GPU job is authorized
until a candidate abstract operator survives the charter's mandatory theorem,
equivalence dossier, exact collapse test, prior-art boundary, and CPU falsifier.

### R12 Exact-State No-Go And Fork-Core Audit

The exact target cannot itself be the invention. If a reachable state `E(h)`
has deterministic event updates, realizes every continuation-query answer, and
uses extensional equality, then `E(h) -> rho_h` is a bijection that conjugates
the learned update to the residual derivative. It is therefore the minimal
Moore transducer and transition monoid in different coordinates. Exact
non-automaton wording is rejected before implementation.

`R12_FORK_CORE_THEORY.md` audits the first approximate replacement. It defines
joint adaptive transcript signatures and requires one current-and-successor
center for every history in a proposed merge fiber. In a convex center space of
affine dimension `D`, a fiber's exact radius is witnessed by at most `D+1`
histories. Pairwise-valid fibers can still require the sharp inflated radius
`2D/(D+1)`; three delta answer laws are the smallest obstruction, with pair
radius `1/2` and global radius `2/3`.

Those statements are useful, but not a new primitive. The shared-kernel object
is an approximate information state / predictive-state representation, the
finite certificate is Helly geometry, and the sharp radius factor is classical
Jung/Bohnenblust geometry. A June 2026 bounded-memory paper already applies the
higher-order compatibility and Helly-certificate idea. FCQ is therefore
rejected for implementation and retained only as a falsifier: any learned
context merge must be tested on multi-history forks, not only pairs.

The next theory target is coherent action extension. Extending each event map
independently into a convex, injective, or hyperconvex ambiguity space does not
guarantee that word updates preserve the original event-monoid relations away
from exact states. R12 now seeks either a simultaneous equivariant extension
theorem with explicit dimension/error cost or a smallest obstruction that
changes the trainable objective. No architecture is authorized while that
question is unresolved.

### R12 Coherent-Action Theorem And Closed-Query No-Go

The simultaneous-extension question now has a complete project-level answer.
`R12_COHERENT_ACTION_THEORY.md` embeds any bounded nonexpansive monoid action
into a hyperconvex sup-norm function space. The embedding is isometric, updates
are coordinate substitutions, every monoid relation holds throughout the
ambient space, and a fiber of diameter `Delta` has optimal merge radius
`Delta/2` with no further word-length error growth. Grid quantization commutes
with the updates and preserves the relations exactly.

This does not survive the invention gate. The displayed unrestricted finite
construction uses `|X| * |A|` coordinates for exact-state set `X` and
transition monoid `A`.
Its reduced form requires an event-closed observable family and is therefore an
observable-profile, PSR, Koopman-pullback, or equivariant linear representation.
The construction buys horizon stability by explicitly carrying the future
observable profile. Classical semigroup linearization, Lipschitz-free spaces,
and injective hulls already occupy this neighborhood.

The smallest prescribed-ambient obstruction is nevertheless useful. A
two-point involution on `{1,2}` has nonexpansive extensions to the three-point
line `{0,1,2}`, but none can remain involutive; the minimum global `a^2=1`
defect is one. Independent generator extension therefore cannot certify a
whole action, even in the hyperconvex interval `[0,2]`.

An orthogonal information-theory attack closes the arbitrary-late-query escape.
`R12_CLOSED_LATE_QUERY_NO_GO.md` treats every still-accessible activation,
certificate, transcript, cache, or context token as retained state. Once the
source is inaccessible, internally generated computation is downstream of that
state and adds no source mutual information. Exact late INDEX needs `n` retained
bits; error `epsilon` still needs at least `n(1-h2(epsilon))`. Search,
recurrence, internal debate, and self-generated proofs cannot reconstruct
discarded arbitrary bits.

R12 must now seek a resource theorem on a structured residual family. The
admissible axes are learnability, dynamic sparsity, amortized verification,
noise stability, or another named cost with a matched comparator. A new exact
state ontology, arbitrary context compression, and coordinate-pullback action
are closed claims. No code or neural experiment is authorized.

### R12 Secret-Shared Causal Bootstrap No-Go

`R12_SECRET_SHARED_CAUSAL_BOOTSTRAP_NO_GO.md` rejects the first attempt to make
a state path information-theoretically compulsory. Splitting a finite-group
target into `U` and `U^{-1}Y` proves a tight `log2|G|` retained-state lower
bound, and a sequence of shares admits a constant-size running product. The
transition-mask variant similarly makes the current event statistically
insufficient without the previous masked state.

The result is a causal-memory control, not reasoning. The final share is a
one-time-padded answer, the running product is the minimal Cayley automaton,
time-dependent transition masks are a gauge transform of the same recurrence,
and state swaps reduce to interchange intervention training. Any bijective
encoding of the retained share is behaviorally equivalent. More decisively,
two models can agree on every distinguishable masked input and disagree on all
unmasked inputs, so masked success gives no transfer theorem. Gate 4 therefore
rejects the proposal before a CPU falsifier or neural fit.

### R12 Structured Residual Resource Law

`R12_STRUCTURED_RESIDUAL_RESOURCE_LAW.md` separates three resources that were
being conflated. Every exact causal realization maps equivariantly onto its
residual system, so it cannot use fewer distinguishable states or fewer than
`log2|R|` retained bits. A structured representation can nevertheless be
exponentially shorter and cheaper to certify than an explicit residual table.

The exact bit-flip family has `2^r` residual states but an `r`-dimensional
Hankel realization, `O(1)` sparse updates and queries, and a polynomial-size
group presentation, versus `r*2^r` black-box transition entries. This is a real
description/certification separation, but it collapses exactly to weighted
automata, OOMs, PSRs, and finite-dimensional linear systems. Likewise, a
structured source language with `p(n)` admissible blocks needs exactly
`ceil(log2 p(n))` retained bits for arbitrary coordinate readback; low entropy
does not itself provide an efficient encoder or updater.

The next target is now sharper: learn a short **nonlinear** residual-action
presentation from ordinary noisy traces with bounded precision, stable sparse
updates, sublinear residual innovation, and a comparator-relative polynomial
learning advantage. Linear Hankel-rank examples are controls, not candidates.

### R12 Axiomatic Presentation Identifiability No-Go

`R12_AXIOMATIC_PRESENTATION_NO_GO.md` closes the naive form of “teach a few
axioms and extrapolate.” A generator assignment that satisfies every defining
relation on its complete state domain does factor uniquely through the
presented category, so all word actions are determined. Identifying the target
action, however, additionally requires every generator to be correct on a
determining set for a declared hypothesis class.

Finite relation and interchange tests do not provide that condition for an
unrestricted neural updater. Any unvisited state-generator transition can be
patched while preserving every frozen loss and breaking the first unseen word
that reaches it. Trivial, conjugate, and nonfaithful representations also pass
many relation suites. Relations are therefore global consistency certificates
for already identified local maps, not a source of identifiability. The
remaining target must explain how a small robust hypothesis class is learned
and how its determining set is covered without hard-coding the algebra.

### R12 Matroid Closure Deduction Target

`R12_MATROID_CLOSURE_TARGET.md` identifies the first deduction-shaped residual
family worth retaining. Histories accumulate matroid premises and a late query
asks whether an element lies in their closure. Exact causal states are flats,
and the flat-indicator concept class of a fixed rank-`r` matroid has VC
dimension exactly `r`, versus `|E|` for arbitrary subset readouts. A binary
rank-two witness already derives `c=a+b` from `{a,b}`.

The gain is conditional. Binary projective matroids still have
`2^(r^2/4+O(r))` flats, so exact state needs quadratic bits, and the VC theorem
assumes the target matroid class is known. With supplied coordinates the
mechanism is Gaussian elimination; with a closure oracle it is standard
matroid learning; over unrestricted unknown matroids the class can recover
arbitrary subsets. The open gate is learning a compact robust closure action
from ordinary traces without handed coordinates, circuits, or oracle access.

### R12 Local Reversible Rule Control

`R12_LOCAL_REVERSIBLE_RULE_CONTROL.md` records a nonlinear polynomial
presentation that does not collapse to low-rank PSR machinery. With labeled
wire tuples and shared rule labels, `L` unknown reversible `k`-bit maps are
recoverable from noisy transitions in roughly
`L 2^k (1-2 eta)^-2 log(L k 2^k/delta)` samples. NOT plus Toffoli supports
universal reversible computation, while a balanced-readout Hankel family has
full rank `2^n` and resists low-rank approximation.

This is a hard control, not the invention. An arbitrary conjugacy destroys the
visible wire locality while preserving abstract behavior. The theorem assumes
the coordinates, affected wires, and sharing map that R12 must discover, and it
does not correct runtime state noise. Any candidate must beat this control with
identical ordinary observations and no structural side channel.

### R12 MDL Identifiability No-Go

`R12_MDL_IDENTIFIABILITY_NO_GO.md` rejects shortest-consistent-program
selection as the missing extrapolation law. Exact identification requires the
finite data to distinguish the target from every equally short incorrect
program, which is precisely a characteristic teaching-set assumption. A
delayed-failure program costs only `O(log L)` extra bits, finite off-support
patches survive, the code ordering depends on the universal machine, and the
ideal shortest-total-program selector is uncomputable.

The valid remainder is a classical iid Occam bound: a zero-error prefix program
of length `K` has risk at most approximately `(K ln 2 + ln(1/delta))/n`. MDL is
therefore retained as a regularizer inside an independently identified
hypothesis class, not as a reasoning mechanism. No CPU experiment is
authorized on MDL alone.

### R12 Hidden-Coordinate Identifiability No-Go

`R12_HIDDEN_COORDINATE_IDENTIFIABILITY_NO_GO.md` proves that adaptive ordinary
observations cannot reveal locality in a conjugacy-closed model class. For any
latent bijection `phi`, conjugating dynamics and interventions and pulling back
the observation kernel preserves every adaptive transcript distribution.
Locality, factorization, and sparsity are therefore not observational
properties without an additional symmetry breaker.

The strongest finite positive result uses the full family of opaque atomic
resets. Their noncommutation graph recovers coordinate groups and their fixed
sets recover coordinate values, giving polynomial identification up to axis
and value relabeling. But the interventions already encode the axes and the
result collapses to interventional causal representation learning. The next
candidate must name a task-native observable asymmetry that is weaker than a
coordinate oracle yet quantitatively breaks the conjugacy.

### R12 Passive Matroid-Learning Boundary

The stronger audit in `R12_MATROID_CLOSURE_TARGET.md` closes passive matroid
discovery as a general route. Fixed-field rank-`r` matroids have a polynomial
description and information-theoretic sample bound, but recovering the matrix
and updating its span is ordinary representation learning plus Gaussian
elimination. A target-aware binary teacher can expose a basis and fundamental
circuits, but that is the missing determining set supplied by hand.

Sparse-paving matroids give the opposite theorem. Distinguishing the uniform
rank-`r` matroid from alternatives with one hidden circuit-hyperplane requires
`binomial(n,r)` passive witnesses in the worst case. Their closure class has VC
dimension at least `binomial(n,r)/(r(n-r)+1)`, exponential at middle rank.
Matroid exchange therefore does not make nonlinear deduction passively
learnable. Binary/projective closure remains a favorable linear control only.

### R12 Noise-Stable Action No-Go

`R12_NOISE_STABLE_ACTION_NO_GO.md` proves that every exact `t`-error-tolerant
binary residual representation has code distance at least `2t+1` and obeys the
Hamming sphere-packing bound. Conversely, decode-compute-reencode makes any
logical action robust under noiseless repair. Exact boundary-state robustness
is therefore coded computation; noisy repair moves the problem to classical
fault-tolerant circuits or cellular automata.

Nonlinear updates do not add correction and can amplify errors: a Toffoli
action maps one pair of distance-one states to distance two. The valid positive
control combines nonlinear local rules with an asymptotically good code, but
it assumes coordinates, code geometry, wiring, independent faults, and
noiseless repair. No CPU experiment is authorized without a resource
separation against structure-aware ECC and fault-tolerant recurrent controls.

### R12 Commutator Factorization No-Go

`R12_COMMUTATOR_FACTORIZATION_NO_GO.md` closes pairwise event commutation as the
missing intrinsic symmetry breaker. Components of the noncommutation graph
generate pairwise commuting subgroups, but multiplication need only form a
central product. Even a true group direct product does not imply product state:
the stabilizer may be diagonal. The explicit `S_3 x S_3` left-right action has
two commuting factors but only one six-state residual orbit.

Exact state-uniform commutation also requires extensional state coverage in the
unrestricted class. When all transitions are known, the positive calculation
reduces to established permutation-group, automata, Cartesian-graph, or trace-
monoid decomposition; it saves description under a supplied product chart but
not residual information. No CPU experiment is authorized on commutators
alone.

### R12 Causal-Address Revelation No-Go

`R12_CAUSAL_ADDRESS_REVELATION.md` preserves a correct private-bank
communication theorem but rejects its neural interpretation. Pointer-chasing
functions give a `Theta(m)` activated-payload gap between one simultaneous
private-bank round and `H` adaptive addressed reads. The smallest witness is two
Boolean function banks: three simultaneous payload bits versus two adaptive
payload bits.

The independent audit found two claim-blocking collapses. First, the retained-
state law is `Hm log m` only when length-one interval queries expose every bank;
for full-chain queries alone, the residual is just one composite table with
`m log m` bits. Second, a normal centralized model may preprocess across banks:
it can store the composite table, keep raw tables plus that table at only
`1+1/H` relative overhead, or use a segment tree for arbitrary intervals. A
depth-matched tied Transformer or recurrent-memory model already has adaptive
routing rounds. The proposed CPU comparison would therefore force a lazy-
evaluation win against an artificially one-round baseline. No CAR fit or CPU
board is authorized.

### R12 Query-Kernel Factorization No-Go

`R12_QUERY_KERNEL_FACTORIZATION_NO_GO.md` proves that future-stable query
kernels are the greatest event congruences inside immediate output kernels.
Their quotient map always gives a subdirect product and gives a true direct
product only under joint-realizability/CRT conditions. Three signatures
`00,01,11` are the smallest missing-combination obstruction; the symmetric
`x,y,x xor y` family shows pairwise complements do not select a canonical
basis. This is output-projected Moore-machine learning plus factor congruences,
not discovery of interacting reasoning modules. No CPU experiment is
authorized.

### R12 Active Verifier Query No-Go

`R12_ACTIVE_VERIFIER_QUERY_NO_GO.md` isolates the exact positive theorem:
balanced disagreement queries identify a finite verifier quotient in
`O(log N / beta)` target-coupled oracle calls. A target-independent verifier
adds no information; a target-coupled verifier is membership/equivalence access;
and compact hypotheses can still require exponentially many calls. The lane is
generalized binary search, active automata learning, or CEGIS, so it remains a
data-generation doctrine rather than a latent-reasoning mechanism.

### R12 Dynamic Frontier Compression No-Go

`R12_DYNAMIC_FRONTIER_NO_GO.md` gives the tight context law for a known active
dependency frontier. Exact memory is the logarithm of the number of possible
frontier supports, assignments, and closed summaries. Minimizing it over
processing orders is pathwidth; factor graphs, tensor contraction, OBDDs, and
recurrent memory use the same separator state. A nonlinear Heisenberg-action
control demonstrates logarithmic residual growth, but that is classical
polynomial-growth group accumulation. The route does not beat a
structure-aware recurrent comparator and receives no CPU board.

### R12 Holonomy State No-Go

`R12_HOLONOMY_STATE_NO_GO.md` closes closed-loop curvature as the task-native
symmetry breaker. Holonomy traces and spectra are gauge invariant and, for a
declared compact finite-dimensional operator family, finitely many joint loop
signatures can identify the connection up to simultaneous conjugation. But
they do not identify which causal state currently occupies the fiber.

Incomplete signatures merge actions that differ on later words. Complete
signatures reconstruct a canonical operator tuple and reduce exactly to matrix
recurrence; adding state-dependent continuation probes is a PSR/OOM. Loop-based
correction requires redundant state-bearing observations and becomes
synchronization or ECC. No CPU experiment is authorized on holonomy alone.

### R12 Closed Deliberation No-Go

`R12_CLOSED_DELIBERATION_NO_GO.md` proves that target-independent internal
self-questioning cannot improve information-theoretic learnability. Every
question, generated answer, critique, proof, and state update is a function of
the same observed data and private randomness, so the transcript has zero
additional conditional mutual information with the target and the finite
computation composes into a one-shot learner with identical output
distribution. A target-answering experiment is an active-learning oracle, not
internally created evidence.

Sequential computation can still improve an explicitly named time, space,
activation, communication, or circuit-description resource. The surviving
theory target is therefore a computational generalization separation under
identical samples, structural prior, and target access. Self-review,
proof-carrying state, or private debate without that theorem receives no CPU
board.

### R12 Polynomial-Coded Action No-Go

`R12_POLYNOMIAL_CODED_ACTION_NO_GO.md` records a rigorous nonlinear positive
control. A degree-`k` action over `F_q^d` has `binomial(d+k,k)` coefficients;
full-rank evaluation identifies it exactly, and correction of `e` adversarial
transition errors is equivalent to evaluation-code distance at least `2e+1`.
Encoding runtime state and applying decode-compute-reencode then gives exact
noise-robust length extrapolation.

The result is not a fair recurrent separation. A universal recurrent control
with the same field/degree promise, state bits, samples, and update compute can
run the same interpolation, decoder, action, and encoder. Unknown coordinates
also destroy the presentation-dependent low degree unless the field basis is
anchored externally. Retain this as an exact interpolation/ECC control; no CPU
falsifier or Shohin fit is authorized.

### R12 Gate-Vacuity Correction

`R12_GATE_VACUITY_AND_WGRQ_PREREG.md` records a claim-critical correction to
the invention charter. Exact finite unrolling proves only extensional
computability; if it automatically rejected a candidate, every bounded
classical mechanism would fail gate 4. Likewise, no candidate can strictly
beat a comparator class that is explicitly allowed to contain and copy that
candidate.

A reduction now rejects a resource claim only when it preserves behavior,
information access, and the preregistered vector of parameters, retained bits,
precision, source bytes, training examples, oracle calls, training/inference
FLOPs, sequential depth, external memory, and external execution within
constant or polylogarithmic overhead. Known machinery blocks primitive novelty
and defines matched controls; it no longer vetoes every bounded training-
protocol experiment. The real information, identifiability, conjugacy, and
delayed-sabotage no-go results remain absolute.

### R12 WGRQ Audit and Stage-A Falsifier

Independent audit rejects Witness-Guided Residual Quotienting as a new state,
algorithm, recurrence mechanism, or oracle-complexity result. Residual merging
is automata minimization/bisimulation; witness continuations are active
automata-learning suffixes; query-blind future state is PSR/OOM machinery. If
every relational label is derived from ordinary counted answers, a fair active
answer-only learner replays the identical policy and derives the identical
labels.

One empirical optimization hypothesis survives. `R12_WGRQ_CPU_PREREG.md`
freezes a delayed-witness edge-parity ring whose only sensor is `x_0 xor x_1`.
Its `2^(n-1)` observable classes need exactly `n-1` bits, and some distinct
classes require `n-2` rotations before any observation separates them. Every
arm receives byte-identical frozen histories, answer bits, equivalence labels,
and witness masks. A 5,136-parameter tied recurrent learner serializes a
15-bit packet across a real process boundary. Sixty paired CPU fits compare
shortest-witness loss, active answer-only, uniform-witness, sham-relation, and
privileged-edge controls under a simultaneous committed-episode decision rule.

This Stage-A CPU falsifier is authorized only in its disjoint namespace. A pass
could claim a relational-loss optimization gain on one finite reversible
family. It cannot authorize language transfer, an H100 fit, or a general
reasoning claim.

### R12 Self-Authenticating State No-Go

`R12_SELF_AUTHENTICATING_STATE_NO_GO.md` proves that local state verification
is coding plus a trust boundary. Detection of `t` bit errors requires code
distance at least `t+1`; correction requires at least `2t+1`. Unrestricted
replacement by another valid state cannot be detected without an external
root, key, counter, checkpoint, or trusted prior state.

A matched recurrent control with the same state bits and update work runs the
same decoder, logical action, encoder, and recovery policy, giving a
resource-preserving identity simulation. The valid gain is a longer reliable
horizon purchased with redundancy and trusted repair, not self-created
reasoning. No CPU board is authorized.

### R12 Query-Distributional Context No-Go

`R12_QUERY_DISTRIBUTIONAL_CONTEXT_NO_GO.md` gives the tight average-case law
for independent source bits and a known late-query distribution. Sublinear
memory with vanishing error is possible exactly when `1-o(1)` of query mass
concentrates on `o(n)` coordinates. A power-law recency distribution yields a
tight polynomial error decay by retaining a sublinear sliding window.

This is functional source coding and weighted INDEX, implemented by a cache or
streaming sketch with the same resource vector. Error falls because discarded
history is almost never queried; worst-case and discarded-coordinate error do
not improve. It is a valid workload policy, not intelligent context compaction,
and receives no CPU board.

### R12 Canonical Residual Naming Control

`R12_CANONICAL_RESIDUAL_NAMING_CONTROL.md` gives the exact symbolic ceiling
for finite observable systems. A minimal `r`-state Moore quotient has
distinguishing suffixes of length at most `r-2`; shortlex access words plus
those residual rows canonically reconstruct its transition table from endpoint
observations through a conservative `2r-2` combined length.

The construction identifies only the observable residual quotient. Hidden
state labels, axes, and any physical states with identical futures are not
identifiable. WGRQ witnesses and merge labels must therefore be generated from
observable residual differences and scored modulo relabeling. The construction
is classical partition refinement and remains a symbolic ceiling, not a new
reasoning primitive.

### R12 Compiler-Prior No-Go

`R12_COMPILER_PRIOR_NO_GO.md` closes recurrence itself as a fair
generalization separation. A uniform acyclic compiler copies the learned
transition cell across length while sharing parameter source nodes, preserving
samples, prior, learned bits, precision, work, sequential depth, and peak
scheduled state. Only reusable program description versus instantiated graph
area differs.

Recurrence can still be an excellent optimization/compiler prior. Any positive
R12 claim must now isolate a training or oracle-allocation advantage against
favorable controls at the same complete resource vector; it cannot attribute
the gain to a loop or tied state update by itself.

### R12 Finite Determining-Family Control

`R12_AXIOMATIC_PRESENTATION_NO_GO.md` now records the strongest legitimate
local-to-global theorem. Exact recovery of every primitive on a finite
determining set inside a declared stationary hypothesis class gives all-length
composition correctness by induction. Majority recovery under independent
noise and the usual Lipschitz telescoping bound quantify the finite and
approximate cases.

Without that class and determining set, delayed sabotage survives every finite
board. With them, every fair structure-aware control inherits the same theorem.
This is a curriculum specification, not an R12 invention.