File size: 3,395 Bytes
7ec01c8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 | # rob-rbyte-v2
Residue router for the SAIR Modular Arithmetic Challenge. Entry class
`model.ResidueRouterV1`, output base 256. Covers tiers 1-3.
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 the operands 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). The answer r is emitted as base-256
digits MSB-first (two digits cover a 16-bit residue). Both step nets are
plain GELU MLPs, width 96, depth 3, ~20k parameters each (~40k total).
- **Tiers 4-10 (p >= 65536):** outside the trained regime; returns [0].
## Provenance
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 the
trained MLP parameters. Randomizing either step net collapses tier-3 exactness:
- random-weight pipeline (both step nets re-initialized): exact = 0.000000
- trained multiply + random reduction: exact = 0.002196 (chance)
so neither step net is scaffolding. The full collapse receipt is in
`t3_collapse_receipt.json`. The two MULTIPLY/REDUCTION step nets are trained
teacher-forced on the local-rule transitions of reference traces; the MULTIPLY
step is saturated over its realizable 272-case domain (100 realizable cases)
and never sees p, the REDUCTION step covers all 512 cases from traces over
TRAIN primes only. Five primes near the 16-bit ceiling (33343, 45137, 54497,
55061, 62071) 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.
## Public benchmark (1100 problems, fixed seed)
- overall_accuracy = 0.314
- highest_tier_above_90 = 3
- deterministic = True (two full runs bit-identical)
- tier 1 = 1.000, tier 2 = 1.000, tier 3 = 1.000
- inference wall-clock < 0.1s for 1100 problems (300s budget)
Static check: clean. No sympy / gmpy2 / eval / exec / subprocess on any path.
See `EVALS.log` and `eval_6d6f6463_1100.json` for the full per-tier breakdown,
and `manifest.json` for the model and training descriptions.
## Files
`model.py` (architectures + routing + fixed wiring), `weights.safetensors`
(tier-1/2 specialist), `t3_mul.safetensors` / `t3_red.safetensors` (tier-3
step nets), `config.json` (per-specialist hyperparameters), `manifest.json`,
`t3_collapse_receipt.json`, `EVALS.log`, `eval_6d6f6463_1100.json`.
|