# REP-005: H-fitting transfer to a fresh finite setting

Freeze and hash this protocol, configuration, design, source snapshot and launcher
before the official run. This study tests the REP-004 recovery pattern in a new
world and partition. It does not reuse selected historical checkpoints, and is not
an identical replay of REP-004's original optimization trajectory.

## Fresh world and withheld observations

The exact state is `(x,y,h)` in `Z31 x Z31 x {-1,+1}`: 1,922 states. Registered
operations, in order, are X, Y, Xinv, R, Rinv, S, H and P. X/Y increment a coordinate;
Xinv decrements x; R maps `(x,y)` to `(-y,x)`; Rinv is its inverse; S increments x by
h; H negates h; P sets y to zero. Spatial arithmetic is modulo 31. Words execute
chronologically from left to right, including both sides of relation controls.

Withhold both context values when `(x+3*y)%31` is in `{0,5,11,17,23}`. This leaves
1,612 training and 310 held states. Train only on edges whose source and target
are training states. Observations have 64 coordinates: 31-way x, 31-way y and
two-way h one-hot groups. No held state, evaluation composition, observation
target or reference decoder contributes to optimization or checkpoint selection.

Coordinates are supplied arithmetic Fourier features
`[1,h,cx,sx,cy,sy,hcx,hsx,hcy,hsy]*sqrt(10/6)`, with angles `2*pi*x/31` and
`2*pi*y/31`. Their norm is sqrt(10); the ten columns have training rank ten.
An additional affine bias is redundant with the constant feature, so operator
coefficient uniqueness or rank eleven is not required for operational adequacy.

Training uses individual actions only. Evaluation uses every length-two word
(64) and 128 unique words at each length 4, 8, 16 and 32. A private local
`random.Random(20261003)` generates these in that order. The next draws generate
separate 128-word length-16 and length-32 families excluding P. Every word is
evaluated from all 1,922 states. The design stores the complete inventory, exact
transition table and hashes of the state partition and evaluation cases. The
projection-free families remain separately reported because projection can erase
an earlier failure. All evaluation words have length greater than one and none
enters training. This is fresh sampling within the same operator family, not
generalization to an unseen kind of operation.

## Fresh native models and paired intervention

Use five seeds, with CPU-seeded initial tensors copied to deterministic FP32 CUDA.
The supplied ten-dimensional encoder is fixed. Each native model has a learned
`10 -> 256 -> 64` tanh decoder and eight affine `10 x 11` operation heads. Train
each for exactly 1,000 full-batch Adam updates at learning rate .003. The head
objective is prediction MSE plus .1 latent MSE, with the encoder detached and
decoder parameters frozen on that gradient path. The decoder receives
reconstruction and one-step prediction losses through detached head tensors.
Means use actual sample and coordinate counts. Tensorizing seeds must sum their
individual mean objectives; averaging across seeds would change the gradient
scale relative to Adam epsilon. Initialization and complete optimizer settings
are frozen by the executable configuration before official execution.

Copy each native model into four arms: native, prediction_latent, latent_only,
and refit. The first is unchanged. The last fits H by CPU float64 least squares
on the training H edges alone, then casts H to FP32; it is a reference, never a
substitute for a failed fitted arm. The two optimized arms start from identical
native H tensors and fresh Adam state. Only H is trainable; the supplied encoder,
all decoder tensors and the other seven heads remain bit-for-bit unchanged.

Both fitting arms use exactly 1,000 updates. If `r` is the number of training H
edges divided by all training edges, prediction_latent minimizes
`r*(Lp+.1*Lz)` and latent_only minimizes `r*.1*Lz`. Lp averages over H examples
and 64 observation coordinates; Lz averages over H examples and ten latent
coordinates. Record the actual edge counts and r. No early stopping, selected
checkpoint, loss reweighting, outcome-selected seed or tuning against evaluation
results is permitted. Log training progress and retain final/partial checkpoints.
Fixed fitting updates finish before evaluation informs interpretation.

## Observable criteria and controls

The learned observation decoder uses independent argmax in the x, y and h groups,
with the first coordinate winning exact ties. A full-state answer is correct only
if all three match integer ground truth. Also report a separate arithmetic
reference decoder: independently maximize the FP32 dot product of latent x/y
coordinate pairs with a circle table built as
`[math.cos(2*pi*k/31), math.sin(2*pi*k/31)]`, k=0..30, converted to FP32.
The first index wins exact score ties, and context is positive only when its
coordinate is >0. Inputs are FP32. On an exact unit circle this is nearest-point
decoding; rounded squared Euclidean distances need not have identical floating
ties and are not the registered rule.
This decoder diagnoses latent transport independently of learned decoding; it
does not enter training. Neither decoder's regression scores are probabilities.

Report every seed, median, worst and range; paired repairs, regressions and
unchanged answers against native; normalized latent error; held versus seen
initial states; H counts and projection presence. Report supported trajectory
strata if computed, declaring whether support concerns the initial state or the
entire path. A perfect native result is a ceiling result, not a reason to find
a worse seed. Failed learned decoding and failed latent transport are distinct.

Reference controls verify all coordinate round trips, analytic intertwining,
inverse and periodic relations, H squared, H-S-H-S, projection idempotence and
rotation conjugacy. Noncommuting word pairs must compare each branch against its
own truth; agreement between two wrong branches is insufficient. Dropping h
merges 961 opposite-context pairs with distinct spatial S successors. A constant
code has zero commutator error yet cannot distinguish all state observations;
its zero residual must never pass adequacy. The unchanged adequate coordinates
establish that this experiment does not demand an additional context dimension.

The primary stress family is length32_no_projection, with length16 and
length16_no_projection reported alongside it. Report both decoders separately.
Call the earlier regression-free recovery pattern transferred on a family only
when native has at least one error, latent-only repairs at least one case, and
latent-only introduces zero regressions across all five seeds. Perfect recovery
additionally requires zero remaining errors for every seed. Otherwise report
partial recovery, regression, no improvement or a native ceiling as observed;
these labels never change execution validity or authorize a selected rerun.
The mixed objective is a paired comparison and does not select the deployed arm.

## Execution, verification and directional decision

Use the existing supervised CLI runner and external artifact root, with explicit
CUDA execution and no CPU fallback. Preserve the inherited 12 GiB process-tree
host RAM, 8 GiB CUDA allocation, 1 GiB device reserve, 10 GiB attempt output and
5 GiB disk reserve limits. Worker wall time is at most 900 seconds and aggregate
execution/verification at most 1,200 seconds. The worker bootstrap must import
the frozen source snapshot, not an editable live checkout. TF32 remains disabled.
The supplemental one-second utilization/power/temperature samples are device-wide
measurements; they do not attribute activity to an individual process.

Before training, compare CPU/CUDA objective losses, gradients and one Adam update
at rtol=1e-4, atol=1e-6, including both fitting objectives and the independent
trial versus tensor-batch controls. Independent NumPy inference covers every
evaluation word and every 127th initial state (`0,127,...,1905`): both decoders
must agree categorically, and per-case latent MSE must agree at those same
continuous tolerances. This is a fixed 16-state subset, not a full-state replay;
the continuous comparison concerns MSE, not every latent coordinate or decoder
logit. The analytic binary64 coordinate control uses absolute tolerance 1e-12;
exact state answers require exact equality.

Hash inputs, source and produced artifacts; preserve every attempt, failure and
partial checkpoint. GPU measurements document real computation rather than an
allocation target. Runtime or protocol edits invalidate an active attempt.
Distinguish incomplete execution, failed validity checks and a valid empirical
null result. Independent inference replay does not establish independent-host
or optimizer-trajectory replication. Run the required pytest suite, math-check
and study verification before claiming completion.

If validity controls pass, compare the objective arms without selecting away
failed seeds. Transfer supports only the declared fresh setting. No transfer or
no measured advantage retains the simpler/reference control. Supplied versus
learned coordinates, topology measurement, diffusion, NPU execution and learned
language interpretation remain separately frozen future stages.