Minimise, sample,
or evolve.

Three computational regimes

Sampling and driven computation are often described as imperfect optimisation. Here they are distinct problems with distinct correctness criteria: an objective gap for minimisation, a distributional distance for sampling, and tolerances on declared observables for driven dynamics.

VOLT: intent and contracts

A VOLT program has four parts: the mathematical intent, a computational contract (what counts as a correct result), a thermodynamic contract (process boundary, input distribution, coarse-graining) and the device requirements. The last two make it possible to compare runs on different substrates — or to establish that they cannot be compared.

// minimise · one source, several possible substrates
problem max_cut(G) {
  state s: spin[G.vertices];
  minimise H(s) = sum((i,j) in G.edges, G.w[i,j] * s[i] * s[j]);
  return best(s), samples(s);
}

execution {
  stochastic     = allowed;
  objective_gap <= 0.02;
  confidence    >= 0.99;
  samples        = 2000;
}

thermodynamics {
  input_distribution = workload.max_cut;
  process_boundary   = encode_to_readout;
  coarse_graining    = logical_spin;
  lower_bound        = mismatch_cost;
}

// sample · the target is a distribution, not a single answer
model infer(y, W, b) {
  latent z: binary[W.rows];
  energy E(z; y) = -0.5 * z' W z - b(y)' z;
  sample  z ~ boltzmann(E, beta);
  return  marginal(z), samples(z);
}

execution {
  total_variation  <= 0.05;
  effective_samples >= 1000;
  stochastic        = required;
}

// the compiler does not assume annealer output is Boltzmann-distributed;
// that claim has to come from the backend, with calibration evidence.
thermodynamics {
  input_distribution = data.y_distribution;
  process_boundary   = load_to_sample;
  lower_bound        = mismatch_cost;
}

// evolve · driven dynamics, never required to settle
system classify_stream(u, target) {
  state      x: real[n]           @node;
  parameters theta: device_controls;

  evolve  dx/dt = F(x, u, theta) for T   @drive(periodic, f=2.4kHz);
  observe y(t) = C x(t);
  train   readout C to minimise loss(y, target);
}

execution {
  latency  <= 5ms;
  accuracy >= 0.95;
  device_noise = allowed;      // hysteresis and memory stay in the model
}

thermodynamics {
  process_boundary = initialise_to_readout;
  time_partition   = measurement_grid;   // finer grid, tighter bound
  coarse_graining  = declared_observables;
  steady_state     = nonequilibrium;     // no detailed balance assumed
  lower_bound      = mismatch_cost;
}

# illustrative ledger output · the figures are examples, not measurements
$ vnstat --run 4417

  program        max_cut          substrate  pbit0 (FPGA, 4096 p-bits)
  regime         minimise + sample           boundary  encode→readout
  ──────────────────────────────────────────────────────────────────────
  samples        2,000            objective gap  0.014   contract met
  wall           184 ms           latency        ok
  ──────────────────────────────────────────────────────────────────────
  measured dissipation      41.2 mJ    (board rail, ±3%)
  mismatch-cost bound        9.7 mJ    (T = 300 K, prior = anneal_family)
  ratio to bound             4.2×
  entropy production         0.043 k_B / update
  bound status               preserved through embedding
  ──────────────────────────────────────────────────────────────────────
  vs run 118 (xbar0)         not comparable — different process boundary
                             (readout coarse-graining differs; narrow or re-declare)

// VOLT 0.1 · compiled to .vng and run on a bench memristor in example 2
system memristor_evolve(u: real) {
  state material: adaptive;

  evolve material for 10 ms using drive.interval(u);
  observe response: real from material.terminal_current;
  return response;

  execution {
    intent    = evolve;
    output    = response;
    tolerance = 0.05;
  }

  device {
    dialects              = [dynamical, adaptive];
    required_capabilities = [drive.interval, observe.terminals];
    calibration           = current_epoch;
  }

  thermodynamics {
    process_boundary = "drive_to_observation";
    energy_class     = uncharacterized;   // no bound claimed for this device yet
  }
}

Worked examples on a laboratory bench

The bench used here is small and deliberately heterogeneous: sixteen memristive devices and sixteen series-RC circuits behind two 16-channel analog multiplexers, measured with an Analog Discovery Studio, and a hardware sampler of sixteen probabilistic bits (p-bits) performing Gibbs updates. It is reached only through Messenger, as any connected device is.

Each script starts with a # vonNeuro line and runs unchanged from VS Code, from the browser's Python lab, or from a terminal with python -m vonneuro_messenger.lab script.py. The names client (signed in), np and plt are predefined.

# vonNeuro
# Charge RC coprocessor 2 with a 1 V step and estimate its time constant.
for device in client.devices():
    print(f"{device.ref:24s} {device.kind:10s} {device.status}")

reply = client.pulse("rc:2", 1.0, 400)               # 1 V for 400 ms
i = np.array(reply["result"]["value"])                # 24 window means, A
t = (np.arange(len(i)) + 0.5) * 400 / len(i)          # window centres, ms
ok = i > 0.05 * i[0]
slope, _ = np.polyfit(t[ok], np.log(i[ok]), 1)
print(f"\napplied {reply['pulse']['applied_v']:+.3f} V, "
      f"I(0) = {i[0]*1e6:.1f} uA, I(end) = {i[-1]*1e6:.2f} uA")
print(f"tau from log-linear fit: {-1/slope:.0f} ms")
print(f"energy at the terminals: {reply['measured_energy_j']*1e6:.2f} uJ")

admin/memristor-array    memristor  online
admin/memristor-d22      memristor  disabled
admin/mux16              rc         online
admin/pbit               pbit       online
admin/sim-rc             rc         offline

applied +1.000 V, I(0) = 759.2 uA, I(end) = 49.97 uA
tau from log-linear fit: 143 ms
energy at the terminals: 104.37 uJ

# vonNeuro
# A VOLT 0.1 program: drive a memristor for 10 ms and observe its terminal current.
program = """
system memristor_evolve(u: real) {
  state material: adaptive;
  evolve material for 10 ms using drive.interval(u);
  observe response: real from material.terminal_current;
  return response;
  execution { intent = evolve; output = response; }
  device { dialects = [dynamical, adaptive];
           required_capabilities = [drive.interval, observe.terminals]; }
  thermodynamics { process_boundary = "drive_to_observation"; }
}"""

for target in ("memristor:15", "rc:2"):
    reply = client.volt_run(program, {"u": 0.5}, target)
    if reply.get("ok"):
        print(f"{target:13s} response {reply['result']['value']:+.3e} A, "
              f"energy {reply['measured_energy_j']:.2e} J")
    else:
        print(f"{target:13s} refused: {reply['error']}")

memristor:15  response +2.856e-08 A, energy 4.27e-11 J
rc:2          refused: device.dialects: adaptive not a dialect of rc (dynamical)

# vonNeuro
# Gibbs-sample a 4-spin ferromagnetic ring on the hardware p-bit sampler
# and compare with the exact Boltzmann distribution.
import itertools
from collections import Counter

J = [[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]]
h, T, n = [0, 0, 0, 0], 1.0, 200

client.nano("connect", mode="serial", port="COM3")
try:
    client.nano("load", J=J, h=h, temperature=T, seed=11)
    samples = [tuple(client.nano_sample(burn_in=200 if k == 0 else 0, thin=10)["spins"])
               for k in range(n)]
finally:
    client.nano("disconnect")

E = lambda s: -0.5 * sum(J[a][b] * s[a] * s[b] for a in range(4) for b in range(4))
w = {s: np.exp(-E(s) / T) for s in itertools.product((-1, 1), repeat=4)}
Z = sum(w.values())
counts = Counter(samples)
tv = 0.5 * sum(abs(counts[s] / n - w[s] / Z) for s in w)
for s in sorted(w, key=w.get, reverse=True)[:4]:
    print("".join("+" if x > 0 else "-" for x in s), f"measured {counts[s]/n:.3f}  exact {w[s]/Z:.3f}")
print(f"total-variation distance: {tv:.3f}  (sampling noise alone ~ {0.5*np.sqrt(16/n):.3f})")

---- measured 0.485  exact 0.450
++++ measured 0.455  exact 0.450
---+ measured 0.005  exact 0.008
--+- measured 0.000  exact 0.008
total-variation distance: 0.046  (sampling noise alone ~ 0.141)

Messenger, the Python API and VS Code

Messenger is the job server between users and hardware. It authenticates each request, checks it against the limits declared for the device, queues it on the shared instrument, meters the time used, and returns the result with its raw data, settings and device identity. A small agent on the computer next to the hardware connects it to the server, so a device does not have to be redesigned to be reachable.

pip install git+https://github.com/vonneuro/messenger-api.git

code --install-extension vonneuro-vscode-0.1.3.vsix

The stack, from meaning to matter

Compilation here is not translation into machine instructions. It is a model-conditioned transformation: program meaning, contracts and the current device model produce an executable physical process, together with a record of the assumptions it required.

Learning rules and thermodynamic accounting

Backpropagation requires an exact reverse pass over stored activations, which physical systems do not provide. The rules below use only what such systems do natively: relax, fluctuate, respond to a drive, and dissipate.

Thermodynamic provenance through compilation

A provenance graph accompanies the program through compilation. At each transformation the compiler records whether the declared bound still holds. A comparison that turns out to be ill-defined is reported as a result in its own right.

Biological substrates

Nothing in the semantic core assumes silicon. A backend qualifies if it can report its state, accept a drive and characterise its own noise. Neuronal cultures, reaction networks and gene circuits can meet these requirements; they differ from electronic devices mainly in timescale, in drift, and in how well their dissipation can be measured.

Biological backends are held to the same contracts. Their dissipation is metabolic and can only be estimated, so the ledger marks it modelled rather than measured and declines comparisons across boundaries it cannot justify. Protocol, provenance and approval constraints are part of the device contract.

Substrate classes

How each class maps onto the three regimes, and whether its dissipation can be measured at a rail or terminal, is reported by a service, or can only be modelled. The first rows are the bench devices used in the examples.

The client, the server and the bench tools are written in Python; the server runs wherever Python and FastAPI do. Neuromorphic backends are intended to lower through existing intermediate representations rather than around them.