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

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:

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:

a09f82684c8a118a633b0bb23e244de961166ebdd3593485d897c8c27deb9747

The three fold commitments are:

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:

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

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:

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:

r12_ettr_il_v2_phase1_architecture_complete_phase2_not_authorized