---
license: mit
library_name: pytorch
tags:
- modular-arithmetic
- neural-arithmetic
- bit-serial
- cryptography
- gru
---

# NeuralHorner (bitserial-modmul-v8)

A single modulus-conditioned recurrent cell that computes `(a * b) mod p` across primes it never trained on,
by running one learned per-step transition inside a fixed bit-serial Horner loop.

- One bidirectional two-layer GRU cell (about 471K parameters), conditioned on the modulus `p`.
- It learns only the per-step transition `s' = (2s + d*x) mod p`; the loop schedule (reduce `a`, reduce `b`,
  multiply the two residues) is fixed by hand. The claim is the learned per-step transition and its
  cross-prime transfer, not discovery of the loop.
- Dynamic-L inference sizes the per-step state width to each prime's bit-length (the dropped bits are always
  zero), which keeps every run under the time budget.

`weights.pt` md5: `8fc8ace7d74538b66ef5980b4e9cd013`

## Results (official open-source scorer, single rented H100 via RunPod)

- All ten scored tiers at exact-match `1.00` (`highest_tier_above_90 = 10`), reproduced across three
  scorer-operand seeds, deterministic. Each full run completes in 163 to 174 seconds against a 300 second budget.
- Cross-prime transfer: `480/480` exact on fresh primes across 64 to 2048-bit widths.
- Anti-cheat: randomizing the weights collapses every tier from `64/64` to `0/64`, so the capability sits in
  the trained parameters, not a hand-coded circuit.
- bf16 decision-safety: 0 flipped answers versus fp32 (`min |logit| = 3.017`).

## Scope and known limits

The model is not claimed to be exact, and where it is weak is stated plainly. A held-out adversarial battery
of six disjoint operand families (768 cases) scores `759/768`; the failures concentrate at
power-of-two-adjacent (Fermat) operands, a single high-wrap transition. A Tier-0 pure-multiplication probe
(operands whose product is smaller than the modulus, so no reduction occurs) scores `40/100`, so the claim is
scoped to modular multiplication on the scored distribution, not general large-integer multiplication. Full
ablations, the failure localization, and a machine-checked Lean proof of the integer algorithm are in the
paper and the code repository.

## Usage

```python
import importlib.util
spec = importlib.util.spec_from_file_location("model", "model.py")
m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
model = m.BitSerialReducer()
model.load(".")  # loads weights.pt from this directory
# inputs are (preprocess_a(a), preprocess_b(b), preprocess_p(p)); see model.py for the I/O contract
```

## Links

- Code and paper: https://github.com/Robby955/neural-horner

## Citation

```bibtex
@misc{robert_sneiderman_2026,
  author    = {Robert Sneiderman},
  title     = {bitserial-modmul-v8 (Revision b49812c)},
  year      = 2026,
  url       = {https://huggingface.co/TrickyRex/bitserial-modmul-v8},
  doi       = {10.57967/hf/9357},
  publisher = {Hugging Face}
}
```

License: MIT, Copyright (c) 2026 Robert Sneiderman.