# R12 ETTR Isolated Learnability Preregistration v2

**Protocol:** `R12-ETTR-IL-v2`  
**Status:** Phase-1 architecture implementation complete; Phase-2 population
freeze and fitting remain unauthorized pending explicit user approval
**Question:** can frozen step-300k Shohin plus a newly initialized ETTR learn
one source-deleted mechanism that transfers across unseen laws, longer
compositions, unseen renderers, combined shifts, and an entirely withheld
task family?  
**Absolute prohibition:** no continuation pretraining, flagship shard access,
flagship optimizer access, protected-checkpoint modification, or output under
a flagship lineage

## 1. Claim boundary

A complete pass establishes bounded, architecture-native synthetic systematic
reasoning by ETTR. It requires:

1. raw WORLD compilation into a categorical typed packet;
2. recurrent execution of a separately disclosed COMMAND;
3. autonomous answer of a separately disclosed QUERY;
4. no raw WORLD, COMMAND, base residual, or KV-state bypass across model
   interfaces;
5. physically source-deleted autonomous development and confirmation
   execution;
6. transfer across rules, depths, renderers, their combinations, and a
   leave-one-family-out fold;
7. causal superiority to equal-budget state-reset, binding-deranged,
   query-only, and parameter/FLOP-matched dense controls; and
8. one sealed, independently authorized confirmation opening.

It does not establish unrestricted natural-language intelligence, justify
continuation pretraining, or prove that raw step-300k Shohin already reasons.

## 2. Frozen architecture

| Item | Frozen value |
|---|---:|
| Protected checkpoint step | `300,000` |
| Protected checkpoint SHA-256 | `211d6b2cddf0c2cf8b12cb0b2d73f9c4440d85f6f531018080c8afd35b2f66a6` |
| Protected Shohin parameters | `125,081,664` |
| ETTR compiler parameters | `21,466,377` |
| ETTR reactor parameters | `29,757,217` |
| ETTR query-reader parameters | `16,474,177` |
| Trainable ETTR parameters | `67,697,771` |
| Complete-system parameters | `192,779,435` |
| Headroom below 200M | `7,220,565` |
| Packet slots / types / relations / values | `64 / 8 / 16 / 256` |
| Reactor horizon / edge cap | `64 / 256` |

The base is read-only, frozen, and in evaluation mode. Its gradient and byte
delta must remain exactly zero. Every `(fold,seed,arm)` initializes new ETTR
weights and optimizer state under the frozen seed protocol.

## 3. Normative component identities

This document is the integration authority. The four component specifications
are normative only for their assigned surface:

| Surface | Document | SHA-256 |
|---|---|---|
| semantic universe, AST, oracles, renderers, queries, quotas | `R12_ETTR_IL_V2_SEMANTIC_GENERATOR_SPEC.md` | `658d8ac9d8897ce63693976079327dd519a455735ee34c7fe442a10fe2f8abad` |
| ontology-to-ETTR packet/trace/tensor mapping | `R12_ETTR_IL_V2_MATERIALIZATION_SPEC.md` | `3dd385c6e10b8c9c5de9019f30e004393c8b480aceb2712294f6e639ef9b5a96` |
| arms, schedule, budgets, metrics, statistics | `R12_ETTR_IL_V2_ARMS_AND_STATISTICS_SPEC.md` | `a7bcc7bd446cf4df0e144bd7db562a538def631871c4f0824f9e81165c54939e` |
| split keys, leakage, authorities, encryption, opening | `R12_ETTR_IL_V2_CUSTODY_SPEC.md` | `1d7668eef7f41d2190a7c410ce9a9df886b87df5877cd44298bcca3cc3e4180e` |

The CPU integration receipt is
`artifacts/r12/ettr_il_v2_spec_integration_audit.json`, with SHA-256
`cc98f616da365215d01611f16c6ae84f7c3e42cdddbe7a5baa543f1eccb524ef`.
Its source is `pipeline/audit_ettr_il_v2_specs.py`. Any component-byte change
invalidates this table and requires a new integrated protocol hash before
implementation.

The literal split-spec SHA-256 is:

```text
a09f82684c8a118a633b0bb23e244de961166ebdd3593485d897c8c27deb9747
```

The three fold commitments are:

```text
cd21d2501e57a275267080ceec35089f5d89e8c83c4d7e3a2ac22c2a39f6eb60
c8509e61b93cbac341c42a2cd73e5d58cd02edbb0eff0b06173df729d83c7d01
8487125d8354be89ff15dceca987a06af2e2dfd457890b387e696002771768b5
```

## 4. Integrated semantic geometry

The three families are typed Horn closure, typed term rewriting, and guarded
resource processes. Every fold fits two and withholds the third completely.
Candidate bytes contain one anonymous surface AST and no family, theory,
split, renderer, presentation, target, oracle, or donor identifier.

A `semantic_core` fixes one theory/evidence instance, two WORLDs, two
COMMANDs, one depth, two semantic queries, and four corner executions. It is
the split, leakage, and statistical cluster.

A `semantic_rectangle` is one presentation/renderer view of a core. It has
four packet corners and sixteen query rows. Each of its four
query/paraphrase slices becomes one current four-row
`ETTRCausalRectangle`. Every slice independently changes its Boolean answer on
all four WORLD/COMMAND edges; existential cross-query contrast is forbidden.

Training geometry per fold is:

| Unit | Count |
|---|---:|
| semantic cores | `576` |
| invariant pairs | `1,152` |
| semantic rectangles | `2,304` |
| causal rectangles | `9,216` |
| query rows | `36,864` |

Each training core emits four views as two mandatory equivariance pairs:

```text
base(renderer 0)          <-> alpha_reorder(renderer 1)
base(renderer 1)          <-> alias_split(renderer 0)
```

Each development and confirmation split has 744 semantic cores, 2,304
semantic rectangles, 9,216 causal rectangles, and 36,864 rows. Non-`all_axes`
cells contain 32 cores with three views; `all_axes` contains 24 cores with
four views. Score-only `ABSTAIN`, `REJECT`, and
`ambiguity_deleted_twin` cases remain on the already frozen seven-variant
board because uniform dispositions cannot satisfy the current causal
rectangle label geometry.

## 5. Composition and native state

All families define dependent command sequences at depths 1-6. Fit depths are
1-3; shifted depths are 4-6. Primary and independently implemented oracles
must agree on every intermediate and terminal state.

Semantic operations are not generic packet transactions. The materializer
alone projects canonical snapshots into:

- 64 slots;
- 8 types;
- 16 binary relation roles;
- 256 collision-free categorical values;
- full packet support masks; and
- one 64-position right-padded generic transaction trace.

The valid trace includes command-register, ontology-state, cursor, outcome,
and final-disposition edits. It must replay exactly to the target packet.
Traces over 64, lossy value recodings, partial support, non-bijective
equivariance, and implementer-selected projections are inadmissible.

## 6. Fitting schedule and arms

One microbatch is one invariant pair: two semantic rectangles, eight causal
rectangles, and 32 rows. Four microbatches form one update. Every model gets
exactly:

- 6,000 optimizer updates;
- 24,000 invariant-pair exposures;
- 48,000 semantic-rectangle exposures;
- 192,000 causal-rectangle exposures;
- 768,000 query-row exposures;
- 405,504,000 charged encoded tokens;
- BF16 forward/backward with FP32 loss accumulation;
- the frozen Muon/AdamW partition and learning-rate schedule; and
- the same eleven objective families and weights.

The five primary arms are:

1. unchanged ETTR treatment;
2. state reset before every one of 64 recurrent positions;
3. deterministic whole-target binding derangement;
4. query reader supplied a canonical empty terminal packet; and
5. a favorable dense recurrent controller matched exactly on active
   parameters, optimizer-family ownership, model calls, objectives, updates,
   tokens, and static loss-path FLOPs.

All 5 arms run across 3 folds and 5 seeds, producing 75 endpoints. Only update
6,000 is claim-bearing. There is no early stopping, best checkpoint, retry,
seed removal, decoder selection, or threshold tuning.

## 7. Source-deletion claim boundary

Differentiable fitting uses the trusted in-process runner. Autograd may retain
source tensors, but compiler, reactor, and reader interfaces enforce logical
non-consumption: downstream modules receive only the sealed packet and their
own stage tokens. No raw upstream tokens, base residuals, or KV state cross a
model boundary.

Every autonomous development, confirmation, and frozen-board evaluation must
use the signed process supervisor. WORLD, COMMAND, and QUERY packages are
network-isolated, parent-linked, and physically removed before the next stage.
Public admission must validate the full receipt chain. A positive claim is
therefore a claim of physically source-deleted inference, not physical
erasure during autograd fitting.

## 8. Leakage and confirmation

Before fitting, the implementation must prove:

- literal split/fold/source/tokenizer commitments;
- zero forbidden raw-row, semantic-world, bound-command, opaque-name,
  token-sequence, normalized-13-gram, and exact graph-isomorphism overlap;
- no stable ontology or metadata route in candidate bytes, paths, lengths,
  masks, order, or package sizes;
- metadata classifier performance at its frozen chance bounds;
- exact quotas, balances, packet capacities, trace capacities, and invariant
  pairs;
- deterministic perfect matching for the deranged arm;
- exact active parameter and static-FLOP equality; and
- complete clean detached source/runtime inventories.

Development and confirmation are encrypted and consume-on-attempt. A
claim-bearing run requires distinct independent authority roles and an
external WORM/CAS opening ledger. Same-account signatures can validate
mechanics only and set `claim_authorized=false`.

## 9. Scientific decision

Promotion requires all absolute transfer thresholds, all five seeds, all
three folds, qualified dense controls, causal intervention correctness,
simultaneous one-sided lower bounds over all 292 treatment-control endpoints,
one sealed confirmation opening, and unchanged success on the three frozen
score-only boards.

The sole positive decision is:

```text
ettr_isolated_synthetic_learnability_systematic_transfer_and_typed_state_advantage_confirmed
```

A valid scientific failure localizes to the frozen component precedence in
the arms/statistics specification. A custody, leakage, source, budget, or
equalization failure yields invalid evidence, not an architecture result.

## 10. Phase-1 architecture gate

Phase 1 is complete only when all of these exist and pass without any weight
update:

1. deterministic semantic generator and all four strict parsers;
2. independent depth-1-through-6 oracles;
3. exact ETTR materializer and independent generic-transaction replay;
4. deterministic quota-aware population generator plus a fail-closed
   cardinality certificate interface;
5. leakage, graph-isomorphism, tokenizer, and metadata audit implementations;
6. invariant-pair scheduler and deterministic derangement matcher;
7. treatment and four equal-budget arm implementations;
8. parameter and operator-level static-FLOP receipts;
9. source-inventoried fit/evaluation runtime;
10. source-deleted autonomous evaluation rehearsal and frozen evaluator; and
11. a new integration audit binding all executable architecture sources,
    fixed transport artifacts, and the protected checkpoint identity.

The literal 20,736-rectangle population, complete population-level leakage
measurements, encrypted confirmation payload, and 75 fitted endpoints are
Phase-2 artifacts: they cannot exist before population generation and fitting.
Phase 1 must nevertheless expose fail-closed builders and validators for each
one. Phase-2 entry order is immutable: generate and certify population,
materialize/freeze/reload it, run leakage and budget admission, validate one
zero-update readiness batch for all arms, then and only then permit fitting.
No fitting may begin merely because the architecture source is frozen.

Current decision:

```text
r12_ettr_il_v2_phase1_architecture_complete_phase2_not_authorized
```