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.