Live demonstration · Reverse Synthetic Network
A network that was
never trained reads
your handwriting.
In the next minute you will grow a digit-recognition network from 1,797 real research samples — inside this tab, with zero gradient descent — then draw a digit and watch it match against neurons you can actually see. At the end, the honest comparison with a trained neural network, including where the trained network wins.
Synthesize from 1,797 real digits
This loads the same scikit-learn 8×8 digit dataset used in the published benchmark and builds the network in your browser: candidate features are generated by mathematical operators, scored by Fisher discriminant ratio, and condensed into prototype neurons — one pass, no training loop, nothing sent to a server.
The network doesn't exist yet. Press synthesize and watch it come into being — it takes well under a second.
Draw a digit
Draw 0–9 below. Your strokes are condensed to the same 8×8 grid the network grew from — that little green grid is literally all it sees.
Watch it think
Synthesize the network first (Step 1).
What a traditional neural network would have done
Trained MLP
backpropagation- Architecture
- 64 → 128 → 64 → 10 (pre-designed) — chosen by a human, before seeing data
- How it learns
- 35 epochs of backpropagation — ≈50,000 gradient updates nudging random weights
- Build time (measured)
- 0.72 s on this benchmark
- Accuracy (measured)
- 96.4% — the accuracy winner, +5.6 points
- Inside the network
- 176 hidden units with no individual meaning — you cannot point at what any neuron knows
Siddha RSN
closed-form synthesis- Architecture
- Discovered from the data — features, neurons, and weights all condensed from statistics
- How it forms
- 0 epochs, 0 gradient updates — one statistical pass and the network exists
- Build time (measured)
- 1.33 s (Python) · ~0.5 s in your browser — you just watched it
- Accuracy (measured)
- 90.8% published full-system benchmark · the miniature you just grew reports its own held-out number above (typically ~95%; splits vary)
- Inside the network
- Every neuron is a visible prototype (you saw yours above); every feature has a name and a Fisher score
The honest summary: on the published benchmark the trained MLP wins on accuracy (96.4% vs 90.8%) and we print that at full size. Your in-browser miniature — which uses the paper's weighted-cosine inference path — typically measures ~95% on its own held-out split, comparable to the MLP; we report it as measured, without claiming a win it hasn't earned under the benchmark protocol. What synthesis unambiguously buys: no training loop, no GPU, an architecture the data designed for itself, neurons you can inspect, and a model cheap enough to rebuild the moment your data changes — right here in a tab, which no training pipeline can do.
What just happened
Four moves, no magic.
- 01Candidates
Hundreds of measurements were generated by mathematical operators on the images — ink coverage per region, stroke profiles, symmetry, moments, frequency patterns.
- 02Selection
Each candidate was scored by Fisher discriminant ratio — how cleanly it separates the ten digits — and the redundant ones were dropped. The data chose its own features.
- 03Neurons
Within each digit class, samples were recursively condensed into prototype neurons along their principal directions of variation. A neuron here is a statistical condensate of real digits — which is why we can show it to you as a picture.
- 04Verdict
Your drawing became the same features, and the answer is simply the nearest prototype under Fisher-weighted cosine similarity. Every step is inspectable; nothing is a black box.
The in-browser network is a faithful port of the research engine (feature families, Fisher selection, recursive prototype splitting, weighted-cosine inference) — the full Python system adds spectral interconnection on top. The mechanism, plainly →