rob-rbyte-v4

• 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

• 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.

Public benchmark (1100 problems, fixed seed)

• 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

Files