R12 SD-CST Physical-Record Write-Bus Preregistration

Status: sole valid training-only run complete; physical-record baseline retained, one-to-one attribution rejected; no scored split was opened

Result: exact source 5c9a2855a202692996e6e4100c927e9d8842bf48, seed 8959672499628717158, and job 694136 completed cleanly on H100 evc37. Both constrained and independent arms reach 48,000/48,000 fit and 8,000/8,000 held-out exact packets with every field/pointer at 100%. All absolute gates pass; the three frozen +5pp attribution gates fail at a 100%/100% tie. See R12_SD_CST_PHYSICAL_RECORD_BUS_RESULT.md.

Source contract: exact architecture, pilot, test, job, and preregistration commit 5c9a2855a202692996e6e4100c927e9d8842bf48; the following documentation-only commits do not change the scientific contract. After source push, raw 64-bit beacon 18183044536483492966 was reduced modulo 2^63 to sole scientific seed 8959672499628717158.

Parent: rejected joint renderer-memory/native-decoder checkpoint SHA-256 4b842e4c2d0d608c32f0fd113b404866be7269676084cdac9b1a00d43cdd298d

Claim class: favorable conventional compiler-mechanics control; no native reasoning, primitive novelty, broad generalization, or Shohin promotion claim

1. Fixed diagnosis

The joint global-query compiler did learn, but its moderate local errors multiplied into zero complete packets. The exact post-hoc audit over all 48,000 fit and 8,000 held-out consumed rows found the following held-out initialization-to-endpoint changes:

Fit and held-out rates differ by at most 0.25 percentage points, ruling out a renderer-parity overfit diagnosis. Gold source-line pooling raises kind to 73.641% but leaves amount at 68.134%. Gold event-span pooling raises identity to exactly 100% over all 56,000 active slots. Therefore:

1. batching, gradients, and objectives are functioning;
2. the frozen declaration fingerprint matcher is sufficient after correct event localization;
3. the dominant unresolved mechanism is physical record/address factorization plus local field extraction; and
4. widening, adding epochs, or adding layers to the failed global-query contract is forbidden.

2. Distinct falsifier

The source has exactly nine newline-delimited physical records: one declaration record and eight event records. The falsifier applies the following fixed mechanism:

1. segment records only at observed newline bytes;
2. encode each record independently with shared relative positions and shared weights;
3. contextualize the resulting unordered nine-record set;
4. emit model logits assigning physical records to the nine semantic slots;
5. use local field motors to emit kind and amount from the assigned record;
6. use a local entity pointer inside each physical record, then reuse the frozen exact declaration fingerprint matcher; and
7. leave the already-successful declaration binding, initial-state transport, late query, categorical tape, executor, motor, reader, and Shohin trunk frozen.

The treatment normalizes assignment logits with 8 Sinkhorn row/column passes during training and uses one deterministic greedy one-to-one assignment during evaluation. The optimizer cannot inspect labels, target spans, tape validity, executor state, answers, or retry feedback when choosing that assignment. Greedy assignment is not represented as Hungarian or globally optimal MAP.

The delimiter and fixed record cardinality are explicit finite-grammar priors. This is a conventional structured parser control, not a proposed reasoning primitive.

3. Matched control

The sole run trains two arms serially:

Both arms:

• reconstruct the same exact parent checkpoint;
• receive byte-identical initial values for every new parameter;
• have identical parameter names, count, optimizer, data order, epochs, updates, losses, and random seed;
• differ only in assignment normalization and hard decoding; and
• retain a byte digest over every excluded parent tensor.

If the treatment reaches the absolute compiler gates but fails the frozen five-point differential gates, the physical-record architecture may be retained only as a conventional baseline and one-to-one attribution is rejected.

4. Frozen architecture and parameter certificate

New trainable modules are exactly the 88 names beginning record_:

• byte and relative-position embeddings at width 384;
• four shared local-record Transformer layers, six heads, FFN 1,536;
• two record-set Transformer layers, six heads, FFN 1,536;
• record/set normalizations, a nine-role head and role embeddings;
• three-way kind and two-way amount motors; and
• local entity query/key projections.

Maximum local record width is 144 bytes. The audit over fit and held-out renderer orbits covers all 56,000 rendered rows and observed zero cardinality violations, a maximum 132-byte payload, and a maximum 133-byte compiler record after retaining the newline delimiter. Overlength, empty, or non-nine-record inputs fail closed.

The complete deployed system must remain strictly below 200,000,000. No parameter is added after this freeze. Historical sub-150M contracts remain unchanged; this is a new user-authorized sub-200M experiment.

5. Data and optimization

The experiment reuses only the already-consumed projected-v2 training JSONL, SHA-256 b7756dbf8d4401dbc5fb897dee53f68758e27200b1ce0d2387631f2f0205ec25. It partitions 12,000 latent programs for fit and 2,000 disjoint latent programs for held-out renderer-orbit mechanics using the existing deterministic ID hash. Fit uses the even-parity renderer orbit; heldout uses the odd-parity renderer orbit. This is adaptive training-only development, not fresh generalization.

Each arm uses exactly:

• two epochs / 3,000 optimizer updates;
• family batch size 8 and evaluation family batch size 16;
• AdamW, lr 2e-4, betas (0.9, 0.95), weight decay 0.01;
• 100-update warmup and cosine decay;
• gradient clipping at 1.0; and
• renderer consistency weight 1.0.

No development, confirmation, answer, state, trajectory, or executor output is reachable. The sole output directory must not preexist. No failed arm may be restarted, extended, widened, or rescored under this contract.

6. Frozen absolute gates

For every held-out renderer, the constrained arm must reach:

1. initial state at least 95%;
2. query and query pointer at least 99%;
3. declaration and initial-occurrence pointers at least 99%;
4. all-nine physical-line pointers at least 95%;
5. active event-occurrence pointers at least 90%;
6. complete event kind at least 95%;
7. complete active identity at least 90%;
8. complete active amount at least 95%; and
9. complete packet at least 80%.

Every fit renderer must also reach line pointer at least 99%, event pointer at least 99%, and complete packet at least 95%. Both excluded-parent digests must remain byte-identical, arm parameter certificates must match, complete system size must remain strictly below 200M, and scored access must be 0/0.

7. Frozen attribution gates and decisions

On the minimum held-out-renderer rate, constrained must beat independent by at least five percentage points independently for:

1. complete packets;
2. all-nine physical-line pointers; and
3. active event-occurrence pointers.

The decision is fixed:

• all absolute and attribution gates pass: retain_physical_record_bus_and_one_to_one_assignment;
• all absolute gates pass but any attribution gate fails: retain_physical_record_bus_reject_one_to_one_attribution;
• any absolute, preservation, parameter, or access gate fails: reject_or_revise_physical_record_bus.

No threshold may change after the seed or output exists.

8. Honest boundary

A pass establishes only that explicit delimiter-bounded physical factorization, local extraction, and model-owned record assignment can compile this finite renderer orbit under the sub-200M cap. It does not establish source deletion by itself, general language parsing, self-selected programs, learned halting, new algorithms, native reasoning, or state reuse. Advancement to a fresh scored board would require a separate post-commit preregistration and new data; current development and sealed confirmation remain unopened.