# rob-rbyte-v3

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

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
  product overflows signed int64, so it is never materialized as an integer).
  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). The
  multiply step is GELU MLP width 128 depth 3 (~35k params), the reduction step
  width 96 depth 3 (~20k params). The two techniques flagged for tier 4 shape
  training: 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 5-10 (p >= 2^32):** 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
geometry). Randomizing a step net collapses its tier:

- tier 3 random-weight pipeline: exact = 0.000000; trained mul + random red =
  0.002196 (chance). See `t3_collapse_receipt.json`.
- tier 4 random-weight pipeline: exact = 0.000000; trained mul + random red =
  0.000000. See `t4_collapse_receipt.json`.

Both tier-3 and tier-4 multiply/reduction step nets reach per-case exactness
1.0 on their full enumerated domains (tier 3: mul 272-case / red 512-case; tier
4: mul 1056-case / red 512-case), so the composed pipelines are exact by the
fixed wiring. Five 17-32-bit primes are held out by identity for tier 4 and
appear in no training trace; the composed tier-4 pipeline is exact (1.0) on all
five on uniform residue pairs and the four edge cases (`t4_collapse_receipt.json`
and `experiments/013-t4-lifted-step/`). The tier-3 held-out primes (33343,
45137, 54497, 55061, 62071) are likewise exact.

## Public benchmark (1100 problems, fixed seed)

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

- overall_accuracy = 0.412
- highest_tier_above_90 = 4
- 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-4 inference 0.1s for 100 problems (300s budget); full eval ~10s

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),
`config.json` (per-specialist hyperparameters), `manifest.json`,
`t3_collapse_receipt.json`, `t4_collapse_receipt.json`, `EVALS.log`,
`eval_official_1100.json`.