# rob-rbyte-v4

Residue router for the SAIR Modular Arithmetic Challenge. Entry class
`model.ResidueRouterV1`, output base 256. Covers tiers 1-5.

Routing is by the size of `p`. Operands are reduced mod p inside
`predict_digits` (the two-argument normalization both reference models use: a
with p, then b with p, never all three).

- **Tiers 1-2 (p <= 251):** the v1 residue specialist. Each operand residue is
  embedded through a shared per-(prime, residue) table; the two vectors are
  added (a discrete-log inductive bias: logs add under multiplication); a
  residual MLP trunk transforms the sum; logits score against a per-(prime,
  class) output table masked to the p classes of the current prime. The answer
  is one base-256 digit. ~2.9M parameters.

- **Tier 3 (251 < p < 65536):** two trained shared local-rule step nets
  composed through fixed wiring. After reduction x, y are 16-bit residues. A
  MULTIPLY step learns the shared carry rule over the carry-save column sums
  and, composed closed-loop through a fixed parity readout, emits the exact
  32-bit product t = x*y. A REDUCTION step learns the shared per-nibble
  borrow/compare rule and, composed through fixed restoring-division wiring,
  emits r = t mod p in [0, p). Plain GELU MLPs, width 96, depth 3, ~20k params
  each.

- **Tier 4 (65536 <= p < 2^32):** the SAME two rules at 32-bit geometry. After
  reduction x, y are 32-bit residues. The MULTIPLY step learns the carry rule
  over the 63 carry-save columns (sum <= 32, carry <= 31) and, composed through
  the parity readout widened to 64 bits, emits the 64-bit product as BITS. The
  REDUCTION step is the identical 512-case per-nibble borrow rule, composed over
  64 division positions x 9 nibbles, emitting r = t mod p in [0, p). Multiply
  step GELU MLP width 128 depth 3 (~35k params), reduction step width 96 depth 3
  (~20k params).

- **Tier 5 (2^32 <= p < 2^64):** the SAME two rules at 64-bit geometry. After
  reduction x, y are 64-bit residues. The MULTIPLY step learns the carry rule
  over the 127 carry-save columns (sum <= 64, carry <= 63) and, composed through
  the parity readout widened to 128 bits, emits the 128-bit product as BITS. The
  REDUCTION step is the identical 512-case per-nibble borrow rule, composed over
  128 division positions x 17 nibbles, emitting r = t mod p in [0, p). Because a
  64-bit residue and the 65-bit division register both overflow signed int64,
  tier 5 carries operands, p, the product, and the division register as BIT
  tensors and never materializes a wide value as an int64 scalar. Multiply step
  GELU MLP width 160 depth 3 (~55k params), reduction step width 96 depth 3
  (~20k params). The two techniques carried from tier 4: reciprocal-operand
  framing (each triple traced as both (x,y) and (y,x)) and Charton-Kempe two-set
  sampling (a small repeated set + a large fresh set).

- **Tiers 6-10 (p >= 2^64):** outside the trained regime; returns [0].

## Provenance

In every tier the carry-save column sums, parity readout, bit shifts,
restoring-division topology, and ge-from-final-borrow decision are fixed
scaffold. The two nontrivial decisions, the carry rule and the borrow/compare
rule, reside in trained MLP parameters (separate nets per tier-3 / tier-4 /
tier-5 geometry). Randomizing a step net collapses its tier:

- tier 3 random-weight pipeline: exact = 0.000000. See `t3_collapse_receipt.json`.
- tier 4 random-weight pipeline: exact = 0.000000. See `t4_collapse_receipt.json`.
- tier 5 random-weight pipeline: exact = 0.000000; trained mul + random red =
  0.000000. See `t5_collapse_receipt.json`.

Every tier-3/4/5 multiply and reduction step net reaches per-case exactness 1.0
on its full enumerated domain (tier 5: mul 4160-case / red 512-case), so the
composed pipelines are exact by the fixed wiring. Five primes per tier are held
out by identity and appear in no training trace; the composed pipeline is exact
(1.0) on all five on uniform residue pairs and the four edge cases. The five
tier-5 gate primes (61-64 bits): 1690313788893089131, 6145258606915434311,
8963783833428354709, 11534118763423864511, 14481575096435149429
(`t5_collapse_receipt.json` and `experiments/014-t5-lifted-step/`).

## Public benchmark (1100 problems, fixed seed)

Run through the official pipeline (`modchallenge evaluate ./submission/rob-rbyte-v4
--total 1100`); the per-tier accuracy and `highest_tier_above_90` come from the
official decoder, not an internal tensor check:

- overall_accuracy = 0.510
- highest_tier_above_90 = 5
- deterministic = True (two full runs bit-identical per tier)
- tier 1 = 1.000, tier 2 = 1.000, tier 3 = 1.000, tier 4 = 1.000, tier 5 = 1.000
- tiers 6-10 = 0.020 (chance; outside the trained regime, returns [0])
- full eval wall ~12s

See `EVALS.log` and `eval_official_1100.json` for the full breakdown and
`manifest.json` for the model and training descriptions.

Static check: clean. No sympy / gmpy2 / eval / exec / subprocess on any path.

## Files

`model.py` (architectures + routing + fixed wiring), `weights.safetensors`
(tier-1/2 specialist), `t3_mul.safetensors` / `t3_red.safetensors` (tier-3 step
nets), `t4_mul.safetensors` / `t4_red.safetensors` (tier-4 step nets),
`t5_mul.safetensors` / `t5_red.safetensors` (tier-5 step nets), `config.json`
(per-specialist hyperparameters), `manifest.json`, `t3_collapse_receipt.json`,
`t4_collapse_receipt.json`, `t5_collapse_receipt.json`, `EVALS.log`,
`eval_official_1100.json`.