Physics as the computer, and the question nobody in the room could answer
The group watched a talk claiming a thousand-fold energy win from computing with coupled oscillators instead of transistors, and got stuck on two questions: how do you train such a system, and how do you physically tune it? This page records the topics, the numbers checked afterwards, and the answers.
Three topics
Oscillator computing
A conference talk from a startup building a computer out of coupled oscillators, played in full and then argued over.
An open-sourced AI chip
A 7 nm many-core RISC-V processor whose IP was open-sourced after the company failed, now publicly reachable — and a weekend experiment run on one.
The energy competition
State of the MNIST leaderboard, how entries get verified, and moving it to a larger host.
The premise the group keeps testing
Arithmetic was the cost
Backpropagation was chosen when sequential machines made counting operations a fair model of cost.
Movement is the cost
Fetching operands dominates energy. Backprop's large memory footprint is now the expensive part, not its arithmetic.
Hill-climb on toy problems
Grind small, fully measurable problems with agents until something cheaper than backprop appears.
Oscillator computing is interesting to this group precisely because it attacks the same wall from the other side: instead of finding an algorithm that moves fewer bytes, it proposes a machine where the computation is the settling of a physical system and almost nothing moves at all.
What an oscillator computer actually does
The published model is a network of phase oscillators. Each one carries a phase $\theta_i$ and turns at its own natural frequency $\omega_i$, while every pair pulls on each other with a strength $K_{ij}$:
The Kuramoto model, 1975. The trained parameters are the coupling matrix $K$ and the frequencies $\omega$. There is no damping term in it.
- Set every phase to a random angle. This is the seed — the counterpart of the noise a diffusion model starts from.
- Drive the desired class. A small second group of oscillators is coupled in with a class-specific coupling, biasing the population toward that class.
- Let it run. The oscillators pull on each other and settle toward a state dictated by the coupling.
- Snapshot the phases at a chosen time. That grid of angles is the latent representation.
- Render. A small conventional decoder — around an eighth of the parameters — turns the latent into pixels.
The released image models reach quality comparable to early diffusion models on small images (32×32 and 64×64). The published work runs on a simulation of the intended hardware; the talk additionally claimed a fabricated test chip and a cost of a few hundred nanojoules per image, which no public document yet substantiates.
Question 1: how do you train it?
The room's guess was that it must be some form of error propagation through the simulated dynamics. That is right, and it is more conventional than the framing suggests: the system is trained by ordinary backpropagation through a simulator of itself. The dynamics are integrated in ten explicit Euler steps, which makes the oscillator half a ten-layer recurrent network whose layer happens to be a physics update. Gradients flow through that unroll by ordinary automatic differentiation.
Conventional, and expensive
Several hundred GPU-hours for the largest released model, using a standard optimizer and a standard generative loss. Nothing about the learning phase avoids backprop or the memory wall.
Where the physics claim lives
Only the forward pass is meant to run on oscillators. "Not a von Neumann machine" is a claim about deployment, not about how the parameters were found.
This matters for a group whose thesis is that the successor to backprop will be found by hill-climbing: the work is evidence that a non-matmul inference substrate can be trained by backprop, not evidence of learning without it.
Four ways to get the couplings, only one of which is in use
| Approach | How the parameters are found | Status |
|---|---|---|
| Hebbian storage | Compute the couplings directly from the patterns you want out, $K_{ij}\propto\sum_\mu\cos(\xi^\mu_i-\xi^\mu_j)$, over stored images encoded as phases. No gradient, no simulator. | Classical; how oscillator associative memories worked for two decades. Capacity is the limit. |
| Backprop through simulation | Unroll the dynamics, differentiate, descend. | What the released model does. |
| Physics-aware training | Run the forward pass on the real device, take the backward pass through a differentiable digital twin. Approximate gradients, exact loss. | Demonstrated on other physical substrates; the obvious route once a chip exists. |
| Equilibrium propagation | Let the system settle, nudge the outputs toward the target, let it settle again. The difference between the two equilibria is the gradient, computed by the physics itself. | Proven for oscillator networks in simulation, including a clean result that the phase shift under weak nudging equals the loss gradient with respect to the natural frequencies. |
The last two are the ones that would make the phrase "not backprop" true. Both are published, neither is what shipped.
Question 2: how do you physically tune one?
Two parameters have to become device settings: each oscillator's frequency, and each pair's coupling. Both are routine circuit design individually; the difficulty is doing them at scale.
A bias current
Starve a ring oscillator's inverters from a programmable current source and its frequency moves linearly with that current. Published designs reach tuning ranges near 100%; a small digital-to-analog converter per oscillator gives a few megahertz per step on a gigahertz ring. Alternatives: switched capacitor banks, or the supply voltage.
A conductance, from memory
On every coupled-oscillator chip built so far, a coupling is a programmable conductance — parallel transmission gates, or a current-biased element — whose strength is a small digital word held in local memory, and whose sign comes from which node of the neighbour's ring you tap: in-phase for positive, inverted for negative.
On damping: it is not the knob
A ring oscillator is self-sustaining. Its amplitude is pinned by the supply rails and recovers from any disturbance in roughly one gate delay, which is exactly why a phase-only model describes it well — the amplitude has already been eliminated. What plays the role damping plays in a passive resonator is the phase restoring rate, and that is set by the coupling strength itself. The classical statement is the injection-locking range, proportional to the injected-to-oscillator amplitude ratio and inversely proportional to the quality factor. Lowering the quality factor of a resonant circuit does shift its frequency slightly and does widen how far a neighbour can pull it — which is the intuition behind "change the damping" — but on a ring you would set the coupling directly instead.
One honest complication. The true interaction between two ring oscillators is not a clean sine; the sine is only its first harmonic. Weights trained against an idealised simulator will therefore not transfer to silicon unchanged — which is the practical argument for training with the hardware in the loop.
The gap between the model and existing silicon
| What the model needs | What shipped chips have |
|---|---|
| A separate learned frequency per oscillator | None. Published arrays run every oscillator at one nominal frequency with a global enable. |
| Continuous signed couplings, hundreds of millions of them | Two to five bits per coupling — five to twenty-nine levels — with sign set topologically. |
| Dense connectivity across tens of thousands of nodes | Roughly two thousand nodes wired to eight neighbours each, or all-to-all at a few dozen nodes. |
This is why the same company's follow-up work on cutting most of the couplings matters more to the hardware story than its image-quality scores do: dense wiring grows as the square of the oscillator count.
The energy arithmetic, checked
The thousand-fold claim is an argument about memory, not about arithmetic: by the proponents' own derivation, eliminating the cost of storing and fetching parameters — while leaving arithmetic exactly as it is — is what produces roughly three orders of magnitude. That framing is consistent with this group's own measurements. Several specific numbers from the talk did not survive checking.
| Claim as stated | Verdict | What the sources support |
|---|---|---|
| A thousand times more efficient | Defensible for the primitive | A coupling update on measured oscillator chips costs femtojoules against picojoules for a multiply-accumulate plus its operand fetch. At the system level it is undemonstrated. |
| A few hundred nanojoules per image | Oscillators only | Scaling measured chips to the model's size lands in that band for the oscillator fabric — but the conventional decoder is tens of millions of parameters and would cost one to two orders of magnitude more on any digital part. |
| Electricity is about half the cost of serving a token | Too high | Roughly 7–13% of total cost of ownership on purchased accelerators. The figure only approaches half under a very different denominator. |
| A physical chip exists and produced the images | Claimed, undocumented | Everything published describes a simulation. No hardware paper, schematic, or image identified as chip output is public. |
A working habit the group endorses: fact-check your own talk before giving it, because the audience now does it live.
Open silicon, and a thermally aware compiler
The second topic was a 7 nm, roughly thousand-core RISC-V processor designed for a customer who walked away. The company failed, the intellectual property was acquired and open-sourced, and the chips are now reachable for public experimentation alongside a working simulator. Two arguments were made for caring: an open simulator lets an agent read the source of the machine it is optimising for, which no closed accelerator permits; and sparsity actually pays there, where on a GPU it usually does not.
A weekend experiment on one of those machines was shown: running matrices of different content — all zeros, all ones, irrational constants, random values — and watching the on-die sensors. Random data flips the most transistors and runs the hottest, a spread of several degrees, and a five-constant model predicted wattage from flip counts to within about twenty per cent. The idea it suggests is a compiler that understands heat generation and dissipation — placing hot work where the cooling is and cold work in the middle, since throttling is a real limit on sustained throughput. The counter-argument raised in the room was that the wins may be small relative to the effort; the reason nobody tried before is that it was simply too hard to reason about, which is the class of problem that has recently become cheap.
The competition
The MNIST energy challenge asks for labelled training images and unlabelled test images in, test labels out, with the energy of both learning and prediction measured on one accelerator. Nothing requires a neural network, and increasingly the leading entries are not networks — closed-form classifiers now hold several tiers at a fraction of the energy of the trained models above them.
| Tier | Target | Best energy | Character of the leading entry |
|---|---|---|---|
| Small, 3×3 images | 67% accuracy | 0.59 mJ | Closed-form discriminant, no gradient descent |
| Medium, 9×9 | 5% error | 174 mJ | Dimensionality reduction plus a closed-form classifier |
| Medium, 9×9 | 2% error | 65 J | Trained convolutional pair |
| Full MNIST, 28×28 | 1% error | 30 J | Layered principal-component filters plus a mixture model |
Energy is measured above idle on a single accelerator, with accuracy averaged over eleven independently drawn datasets.
Two process points came up. First, verification is now part of the work: a suspiciously cheap entry was re-run independently before being accepted, and interpreting what an agent actually did has become a task of its own — one participant has been reconstructing the leaderboard's history to understand which ideas are doing the work. Second, an entry tier at 15% error was added on the spot, on the theory that a visible empty slot recruits better than a hard one.
Follow-ups
- Publish the answers to the two oscillator questions. The material on this page — what is actually trained, and how frequency and coupling become device settings — goes into the group's notes so the next reader does not restart from scratch.
- Move the competition to a larger host. The measurement script is with the prospective host; the accuracy targets should be frozen and the new entry tier added before any wider announcement.
- Harden the scorer. Two concrete exploit classes raised at the previous meeting remain untested, as does a transfer check against MNIST-like datasets to catch entries that overfit to the specific benchmark.
- Settle the ranking rule. The board still reports two cost models side by side. One of them should rank and the other should be reported.
- A baseline oscillator entry. Train an oscillator network on the medium tier by both routes — ordinary backprop and equilibrium propagation — and score it like everything else. It will lose on energy, and the size of the loss is exactly the simulation-versus-physics gap the whole argument rests on.
- Next meeting, 28 September. A walkthrough of the matrix-multiplication visualisations, deferred from this one; an analog-circuit learning competition still owes the group a session.