The quantum pond

Reservoir computing in six steps, with water standing in for the qubits. Nothing here learns except one row of numbers at the end.

One of six

Drop some stones

What any of this has to do with quantum

A reservoir is anything messy enough that poking it produces a complicated, input-dependent state which fades after a few seconds. Water works. So does a small quantum circuit. The trick is that you never train the reservoir — you only train a simple readout sitting on top of it, which is one equation solved once.

The mapping

A stone landingA pulse rotating a qubit, encoding one input value
Ripples spreading and crossingThe register evolving and entangling under its own Hamiltonian
25 floats reading heightsMeasuring each qubit, averaged over many repeats
Ripples dying awayDecoherence — the fading memory that makes it usable
Weights × readingsIdentical. A linear readout, fitted once, no GPU
Noise I add by handFree. Every measurement is a coin flip

Where the new stones come from

Nothing is choosing anything. The readout is a fixed map from surface to next stone. But once it takes over, its own stones are the only thing going in, so the surface becomes a function of everything it has done. A stone landing a fraction off hits a different wake, and the difference compounds. Deterministic, unpredictable — the same reason a feedback delay never settles. Measurement noise then keeps nudging it, and the weights keep steering it back toward patterns that look like yours.

Why bother with qubits

Not accuracy. On most benchmarks quantum reservoirs land roughly where classical ones do. What you get is dimensionality — n qubits carry a state of size 2n, so a handful gives you an enormous feature space to fit against — and randomness that is physical rather than pseudo. For generative work that second part is the interesting one: the drift is a property of the hardware, not a seeded RNG you could have faked.

Where the analogy breaks

Reading the water doesn't disturb it. Measuring a qubit collapses it, so you either rebuild the state from scratch each time or use weak measurements that only partly destroy it. That constraint shapes every real implementation, and it has no counterpart in a pond.