Proof, not a slogan
Don’t take our word for it — run it.
Chaos is the adversary here, on purpose. A Lorenz system has a positive Lyapunov exponent: any last-bit difference is amplified exponentially until two trajectories that started identical end up unrelated. So a chaotic integrator producing the same bits on two different CPU architectures(x86 and ARM) is a hard proof, not a soft one. Flip fused multiply-add back on and the trajectory visibly diverges — that’s the whole point.
The artifact
examples/lorenz_f64.mind — a loop-carried f64integrator on MIND’s strict lowering path: arith.mulf/arith.addf, no fmuladd-contraction, no fastmath flag, fixed source order.
# examples/lorenz_f64.mind — chaotic Lorenz–Euler integrator, strict f64 path.
# arith.mulf / arith.addf, no fmuladd-contraction, no fastmath, fixed source order.
fn lorenz_f64(steps: i64) -> f64 {
let sigma = 10.0
let rho = 28.0
let beta = 8.0 / 3.0
let dt = 0.01
let mut x = 1.0
let mut y = 1.0
let mut z = 1.0
let mut i = 0
while i < steps {
let dx = sigma * (y - x)
let dy = x * (rho - z) - y
let dz = x * y - beta * z
x = x + dt * dx
y = y + dt * dy
z = z + dt * dz
i = i + 1
}
x + y + z
}Compile it, run it, hash it
The output is native code— you don’t need our runtime to reproduce this. The open-source mindc compiler emits a native binary you run directly; then hash the result. It is bit-identical across x86 and ARM CPUs under the no-FMA-contraction contract (-ffp-contract=off ≡ --fmad=false).
# Compile to native code — no runtime, no VM, no interpreter. mindc build examples/lorenz_f64.mind -o lorenz ./lorenz # x86 CPU ./lorenz # ARM CPU (NEON) # → the same f64 bits on both CPUs, under the no-FMA-contraction contract. # (GPU bit-identity — NVIDIA CUDA — ships in the commercial mind-runtime.)
Why FMA is the fault line
Strict path — --fmad=false
Every multiply and add rounds independently, in fixed order. x86 and ARM CPUs emit the same bits. The trajectory is identical on both, step for step, all the way to step 5000.
FMA fused — --fmad=true
A fused multiply-add rounds once where the CPU rounds twice — a last-bit difference. The positive Lyapunov exponent amplifies it, and by a few thousand steps the two trajectories are visibly unrelated.
Same source, same inputs. The only variable is whether the backend was allowed to fuse — and MIND pins that at emit time so it can’t.
Self-verifying
You don’t have to trust the run either. Each artifact embeds an evidence chain whose trace_hash = SHA-256 of the canonical mic@3 bytes. Identical (source, inputs, version, target) ⇒ identical trace_hash. mind verify checks a run reproduced rather than asking you to believe it.
# The artifact is self-verifying. trace_hash = SHA-256 of the canonical mic@3 bytes. mindc build examples/lorenz_f64.mind --emit-evidence -o lorenz mind verify ./lorenz # → identical (source, inputs, version, target) ⇒ identical trace_hash. # Confirms a run reproduced — without trusting the build host.
What’s proven, exactly
We claim only what is gated and verified today, and mark the rest honestly.
Scalar f64/f32 strict path (fixed order, no FMA-contraction) — bit-identical x86 == ARM (GPU/NVIDIA ships in the commercial mind-runtime) | proven |
| Integer & Q16.16 fixed-point — byte-identical x86 == ARM | proven |
Broader vector f32/f64 reductions (tensor sum, GPU) — ordered reduction trees, ~1e-4 tolerance, not yet bit-identity | in progress |
| Post-quantum ML-DSA (FIPS-204) signing of the evidence chain — the next milestone | in progress |
Full detail, per operation, lives in the Determinism Contract.
Kick the tires
Reproduce the hash, read the contract, or come argue about it — the determinism thread is where this gets hashed out.