A thermodynamic SDE recovers a matrix inverse

The question

A recent talk described a thermodynamic computing chip as being, in effect, a stochastic differential equation. Instead of forcing transistors to settle at zero or one, you let the chip's own noise do a biased random walk and settle into place. The striking claim: once it settles, the chip behaves according to the inverse of a matrix you built into it.

That is a strong claim, and it is the kind that usually gets asserted and waved past. The honest version of it is testable. If the chip is really running that kind of equation, then a faithful software simulation of the same equation must land on the same answer that a standard matrix solver gives. So the question for this experiment is narrow and answerable: does the simulated process actually recover the matrix inverse, and by how much does it miss?

The method

I simulate an Ornstein-Uhlenbeck process, a noisy pull toward a target, written as dx = -(A x - b) dt + sqrt(2) dW. Here A is a symmetric positive-definite matrix, b is a vector, and dW is the random kick at each step. Left alone, this process does not wander forever. It settles into a steady cloud of points whose shape is fixed by A and b.

The mathematics says exactly where that cloud sits. Its center (the stationary mean) should equal A⁻¹ b, which is the solution of the linear system A x = b. Its spread (the stationary covariance) should equal A⁻¹, the matrix inverse itself. So if I run enough independent chains for enough steps and then measure the center and the spread of where they end up, those two measurements should reproduce the linear solve and the inverse, with no matrix inversion ever written into the simulation. The noise does the algebra.

The criterion is not something the simulation gets to author. The center and spread it produces are checked against A⁻¹ b and A⁻¹ computed directly by a standard solver (numpy.linalg.solve and numpy.linalg.inv). Linear algebra holds the answer key. The SDE is the thing under test.

Run parameters, fixed and re-runnable:

Matrix

symmetric positive-definite, size 4 by 4, condition number 2.33 (well-conditioned, so the steady state is reachable without numerical strain)

Chains

6,000 independent walkers, averaged at the end

Steps

40,000 per chain, step size 0.005, Euler-Maruyama integration

Seed

fixed, so the same run reproduces the same deviations

Reference

direct linear solve and direct matrix inverse from a standard library

The measured outcome

Both targets land inside the 5 percent bar that was set before the run, so both return a crucible MATCH. The bar is a deliberate, stated tolerance for a stochastic estimate, not a number tuned after the fact to make the result pass.

Read plainly: a process that only ever adds biased noise, with no inversion step anywhere in it, recovered both the solution of a linear system and the inverse of the matrix. That is the SDE-settles-to-the-inverse claim, confirmed in code against an answer key it did not write.

What is re-checkable

Nothing here asks to be trusted. The whole experiment is meant to be re-run by anyone who doubts it, with no special data and no outside party.

• The simulation. The script discovery-forge-c3/c3_sim.py is seed-fixed. Run it and it prints the same two errors fed to the verdict, plus the condition number of the matrix it built.
• The verdict. The thesis (the two claims and their named falsifiers), the measurements, and the MATCH or DRIFT verdicts are sealed as JSON: c3-thesis.json, c3-measurements.json, c3-sim-result.json. Each claim states what would have refuted it: a relative error above 5 percent. Neither did.
• The seals. thesis 8a78ee06, verdicts 170cce85, measurements bae0d420, run 825cc0d1. They fingerprint the exact inputs and outputs, so a later run that drifts from these can be caught.

The discipline is the point. A result is allowed to claim MATCH only if it was derived or simulated and then checked against a criterion it did not author. This one was. The criterion is linear algebra, held by a standard solver, outside the process under test.

The honest boundary

This confirms one leg, and only one. The mathematical claim, that an Ornstein-Uhlenbeck SDE settles to the matrix inverse, is now a re-checkable MATCH. That is the simulate leg.

Whether a physical thermodynamic chip actually realizes this, inside its real noise floor, its device mismatch, and its analog limits, is a different question. That is the render leg, and I have not measured it. There is no chip on my bench and no measurement of one in hand. So the render leg stays UNVERIFIABLE here, stated plainly rather than quietly folded into the win. A simulation matching linear algebra is genuine evidence for the mechanism; it is not evidence that any particular hardware hits these numbers.

This is how the forge is meant to move: one leg at a time, each one named, and the unproven leg left labeled unproven instead of borrowed against. Calling the math result a MATCH and the hardware result UNVERIFIABLE in the same breath is the whole accountability discipline working as designed.

Where this sits

C3 is one card in a v0 Discovery Forge: a small assembly line that takes a claim from a research source, attaches an explicit falsifier, runs a check, and returns a verdict of MATCH, DRIFT, or UNVERIFIABLE. Most cards in the set are still proposed, dated to outside data, or out of current reach, and they are marked that way. C3 is the one that could flip to a real verdict with only local code, and it did. It is shown here as a worked example of the method, not as a sweeping claim about thermodynamic computing.