A sealed room where a verdict is decided and no hand reaches inside.
Every anti-overfitting statistic in quantitative finance divides by one input: how many strategies were tried before the one being shown. For forty-six years that number has been typed in by the person being judged. MIZAN makes it the leaf count of a committed Merkle tree, recomputed inside a zero-knowledge proof. What comes out is a 225 KB receipt any allocator checks offline in ~81 milliseconds, while the strategy never leaves its maker's machine.
The last self-reported number in finance, made structural.
A deflated Sharpe ratio asks: given how many strategies you tried, how surprised should I be that this one looks good? Answer honestly and most edges evaporate. So the number of tries, N, has always been the one input nobody could check, and the one input everyone rounds down.
In MIZAN, N is a Merkle leaf count. Each strategy you evaluate is a committed leaf; the tree is fixed before the gate runs; the proof reads the leaf count and cannot be handed a smaller one. You cannot try a thousand and report three. The deflation is computed against what you actually did, and this is enforced maximally: the statistic uses the full committed count, not a subset. The number that was always a confession is now a fact the proof carries.
Fingerprint first. Then no hands reach in.
The gate runs inside a RISC Zero zero-knowledge virtual machine: the sealed room. The order of operations is the guarantee. The strategy and its data are committed first, as a cryptographic fingerprint, and only then does anything run. You cannot see the result, dislike it, and change the inputs; the inputs were sealed before the result existed.
Strategy, data, the out-of-sample split and the cost model are hashed into a commitment. This is locked before evaluation.
The committed strategy runs on the committed data, inside the room. Net of the committed costs. On the committed split.
The anti-overfitting battery runs on the result, against the committed trial count. No input can be swapped now.
Nobody, not the maker and not MIZAN, can reach in and move a number once the fingerprint is set. The proof attests that the code that ran is the code that was committed.
One committed strategy. A battery of independent seals.
Each seal is its own credential on the same committed strategy, so an allocator reads exactly which tests a record passed and which it did not. The both-schools battery below entered in era v11 and runs in the live era, v12, which adds the completion statistics (MinTRL, robust-Sharpe block bootstrap, Model Confidence Set, trial-correlation disclosure) and enforces the protocol cost floor in-circuit. Era by era →
Deflated Sharpe (DSR)
The Sharpe ratio corrected for the number of trials and the higher moments of the return stream: the Bailey–López de Prado / Harvey–Liu multiple-testing deflation. The seal the trial count feeds directly.
recomputed in proofPBO
Probability of backtest overfitting, computed across all 12,870 balanced splits, C(16,8) at S=16, not a single favourable partition.
recomputed in proofPurged CPCV
Combinatorial purged cross-validation: leakage between train and test folds is purged, so a record can't borrow information across the split.
recomputed in proofPSR · SPA
Probabilistic Sharpe and Hansen's superior-predictive-ability test: is the edge distinguishable from the best of many lucky draws? Run over the committed ledger; the SPA seed is derived in-arm from the data and trial-stream, so it can't be shopped.
recomputed in proofMinBTL
Minimum backtest length: is the track long enough that the Sharpe could be trusted at all, given the trial count? Currently consistency-checked verifier-side on read, not claimed in-circuit. We label what runs where.
checked on verifyAnnualization basis
A window / annualization-basis sanity check the verifier applies to the receipt on read, stated plainly as verifier-side, not claimed to run in-circuit. We label what runs where, and this one runs on verify.
checked on verifyTrust no one. Recompute it yourself.
A credential is a 225 KB receipt. Verifying it is a local cryptographic check: ~81 milliseconds, offline, no server call to us, no account. The verifier confirms the proof is valid and the committed hashes match; it never needs the strategy, and neither do you.
If checking the proof isn't enough, reproduce the numbers. About two hundred lines of dependency-free Python recompute every committed statistic to the digit from the public inputs. The standard that lets you do this, VTR-1, is frozen and published on SSRN. The verifier is not something you have to trust us to run; it is something you run.
The asymmetry is the security. Verifying is cheap: ~81 ms on a laptop, trusting no one. Minting is not: each credential is a real STARK proved on an NVIDIA H100 or comparable GPU, minutes of GPU work per mint, not milliseconds. That gap is deliberate: a forger gets no shortcut, because to fake a verdict they must run the same heavy, honest proving the wall demands, on the same locked circuit, against the same committed inputs. The check is trivial for everyone; the forgery is expensive for the claimant. The adversarial review of the whole construction is public: the security model, in full →
Committed forever. Anchored in Bitcoin.
Nothing deleted, nothing reordered.
Every credential is a permanent, ordered entry; earlier is senior. The whole registry commits to a single registration root, one Merkle root over every entry, so the state of the wall itself is a number you can check.
No anchor shown, no claim made.
Anchor state is printed per credential: Bitcoin via OpenTimestamps, plus RFC-3161 where stamped. A record chained forward extends past each anchor, so it reads LIVE: a pulse that can only have been built forward, never backfilled.
The engine is a hash.
A version of the gate is identified by its image id: the cryptographic hash of the exact circuit that ran. That is what an era is. When the gate improves, a new era begins, but the old one is never revoked. A credential minted under an earlier era verifies against that era's image id forever; the rules it was judged under are pinned to it and cannot be quietly changed after the fact.
| Era | Stamped | Guest image id | Status |
|---|---|---|---|
| v12 | 2026-10-13 frozen · live 2026-10-14 | 659bdb678a3d7a26… | live |
| v11 | 2026-07-25 | 3ac3b10b7930324d… | superseded |
| v10 | 2026-07-22 | dafad185fe3e0079… | superseded |
| v9 | 2026-07-21 | b9dc68467927d2cd… | superseded |
| v6 | 2026-07-20 | 12b2f0429fdec5ae… | superseded |
| v5 | 2026-07-18 | dc3ee0310eee4a24… (verifier-embedded) | superseded |
| era_a | 2026-07-11 | none archived, not guessed | superseded |
For the strategy the rules can't express.
Some strategies don't fit a declarative rule language: a machine-learning model, a black box, a multi-asset book. The sealed path handles them: your bot emits its committed positions, and the proof runs the gate over that committed position stream. Your code, your model, your parameters: none of it enters the room. What the strategy did becomes checkable; what it is stays sealed. This is also how a trading AI proves conduct: a compact model can be recomputed in-circuit, and any model can prove its behaviour through the sealed path. Since era v12 the rules DSL also expresses close-evaluated bracket exits (profit-take, stop, time). Verifiable AI →
What the proof does not claim.
A referee that overstates its reach is worth nothing. Here is the line, drawn plainly, because the honesty is the product.
The specification, in one table.
| Proof system | RISC Zero zkVM: STARK-based zero-knowledge proof of correct execution of the committed guest program. |
| Live era | v12, guest image id 659bdb67…, live since 2026-10-14. v11 (3ac3b10b…) superseded and still verifiable. |
| Proving | NVIDIA H100 (sm_90) or comparable GPU, minutes of GPU work per mint: the heavy, unshortcuttable side of the asymmetry; concurrency is cost-guarded. Verifying the result stays ~81 ms on any laptop. |
| Trial count (N) | Merkle leaf count, committed before evaluation; deflation computed against the full committed count (enforced maximally). |
| Statistical battery | DSR, PBO (12,870 splits, C(16,8) at S=16), purged CPCV, PSR, SPA in-circuit (DSR carries the Harvey–Liu / Bailey–López de Prado deflation); MinBTL and the window/annualization-basis check verifier-side. |
| Receipt | ~225 KB, verified in ~81 ms offline: no server call, no account. |
| Independent reproduction | ~200 lines of dependency-free Python recompute every committed statistic to the digit. |
| Registry | Append-only, ordered by seniority, committing to one registration root (Merkle root over all entries). |
| Time anchor | Bitcoin via OpenTimestamps, plus RFC-3161 where stamped: no anchor shown, no claim made. |
| Versioning | Each era is an image id (circuit hash); superseded eras are never revoked; credentials pin to their era forever. |
| Standard | VTR-1: frozen, published on SSRN, CC BY. The verifier is free and public, with an MIT-licensed reproduction kit; the prover is the private part. |
Don't take the description on faith. Verify a real one.
Every credential on the public wall came out of the room above, including the refusals. Reproduce any of them to the digit, read the frozen standard, or bring your own strategy and watch the gate decide. Free while open testing lasts.
Research and verification artifacts. Not investment advice; no offer or solicitation. Backtested and hypothetical performance is not indicative of future results and is net of committed trading costs only. A strategy submitted for proof is never transmitted, stored, or revealed by MIZAN. Figures (receipt size, verification time, split count) describe the current engine era and are reproducible from the public inputs.