---
tags:
- ClaudeCode
---
# rob-constructed-v1: constructed ReLU circuit for exact (a·b) mod p

A fixed-weight linear + ReLU network that computes `(a * b) mod p` exactly at
every scored tier, from 3-bit primes (tier 1) to 2048-bit primes (tier 10).

**This is a constructed arithmetic circuit, not a trained model.** Read the
manifest's `model_description` and `training_description` first; they state the
provenance plainly. The weights are set by construction (two numeric constants,
`1` and `2^16`, plus the structural wiring in `circuit.py`). There is no
training set, no optimizer, and no fitted parameter.

It is submitted as part research, a hand-encoded algorithm that meets the time and space budget and is
exact on every scored tier. 

## What it computes

The forward pass is linear maps, ReLUs, and 1-D convolutions only: no integer
tensor arithmetic, no `einsum` on the inputs, no product of two activations.
Multiplication uses the binary-gated-product identity
`b*v = relu(v - 2^16*(1-b))`, which replaces every bilinear operation with a
ReLU. The pipeline is schoolbook multiply (gated partial products into
carry-save columns), MSB-first bit-peel carry normalisation, then Barrett
reduction (HAC 14.42, base `2^16`, `k = n` limbs) with a borrow-out comparator
and at most two conditional subtractions. All weights are on the `{0, ±1, ±2^t}`
grid, stored float32 and computed float64 (exact on integers below `2^53`; the
measured precision margin is comfortable at every tier).

## Interface

- `preprocess_a`, `preprocess_b`: parse the decimal operand (own argument only).
- `preprocess_p`: parse `p`, route to the circuit width from `p`'s bit length,
  and precompute the Barrett reciprocal `mu = floor(2^(32n)/p)` from `p` alone.
- `predict_digits`: reduce the operands `mod p` to the limb width (a standard
  intermediate reduction, the same one the reference models use, not the
  answer), run the routed circuit forward, and emit base-`2^16` limbs. The
  harness decoder reads them MSB-first and assembles the integer.
- `output_base = 65536` (one base-`2^16` digit per limb), within the schema's
  `[2, 2^32]`.

Inputs whose prime exceeds the 2048-bit tier ceiling return `[0]`.

## Files

- `circuit.py`: the primitives, the `ModmulCircuit` module, preprocessing
  helpers, and safetensors I/O. Vendored verbatim from the verified
  construction so the submission is self-contained in the sandbox.
- `model.py`: the `ConstructedCircuitModel` entry class, with per-tier routing,
  preprocessing hooks, and the batched forward pass.
- `manifest.json`: entry class, `output_base`, and the honest model and
  training descriptions.

No weight files: the circuit needs none. That is part of the honest picture.
A submission with no trained parameters is, by the rules' own wording, a circuit
rather than a model.