gdp-wired
0.56All 29 of IC3Syn's protocols proven, nothing written

gdp-wired

An automatic prover for stateful rules.

Budgets, caps, rate limits, workflows, access policies. You write the rule and the laws it must keep. gdp-wired proves them with no proof to write, shows a real run that breaks a law when it's false (found by searching on the GPU), has every proof checked again by Lean, and ships the rule as JavaScript.

In a minute · npx gdp-wired-cli check

One comment. One command.

TypeScript is the native, first-class path on both routes. Write rules and laws with the gdp-wired TypeScript library API and proveRule, or run npx gdp-wired-cli check file.ts on plain TypeScript/JavaScript, Effect services or XState machines with // gdp: law comments. The CLI also reads Python, Go, Rust, Java, Kotlin, Swift, Ruby, Elixir, C and C++. See what each reader supports and refuses.

The CLI. A Python budget check that passes every test, broken by one comment and one command, fixed and proven; then the same check on Java and Kotlin.
TypeScript laws, and Effect. The rule written in TypeScript, proven and broken; an Effect service read as it is, its law one comment.

Both narrated, with captions. Every language, with its real output

The film

The frontier film, narrated, with captions. The short cut and the launch film

The frontier · measured at 0.30, CHC-COMP since

At the front of the field, in our harness*

One automatic prover against each benchmark's best tool: our worst run against the best rival's best run. Every answer is checked by the kernel, and none is wrong.

* In our harness: 60 s a task; not yet confirmed under each competition's official setup. TIP, SV-COMP and TermComp as measured at 0.30 on Modal (2 vCPU), the rivals side by side on the same boxes. CHC-COMP as measured now on boat, each tool alone on 4 vCPUs, three runs: level with Golem by our rule (a lead counts only when our worst run beats the rival's best). At 0.30, four side-by-side batches on Modal (2 vCPU) measured 1,165–1,168 against Spacer's 1,159–1,160 and Golem's 1,153–1,155: a lead of 5 then, which the fair setup doesn't show. Bars start at zero, each row on its own scale; the labels give every run's range.
The numbers as a table
Solved tasks, in our harness (CHANGELOG, compare/). The lead is our worst run against the rival's best. CHC-COMP on boat, each tool alone on 4 vCPUs (at 0.30 on Modal, side by side: 1,165–1,168 against Spacer's 1,159–1,160, a lead of 5 then).
Benchmarkgdp-wiredBest rivalRivalLead
CHC-COMP LIA-Lin1,159–1,169Golem (Spacer (Z3) about 1,156)up to 1,163level
TIP 2015212–213Vampire187+25
SV-COMP termination246Ultimate Automizer224+22
TermComp ITS, terminates613–614KoAT2601+12
TermComp ITS, doesn’t terminate538–542LoAT532+6

0.49 · IC3Syn's distributed protocols

All 29 protocols. Nothing written.

IC3Syn (Cao, Wu, Yao, Wei, Chen, Ma, arXiv 2605.24619, May 2026) synthesizes invariants for 29 TLA+ protocols: leader election, consensus, Paxos, two-phase commit, sharded key-value stores, lock services. We ported the whole suite and checked each port against TLC step by step. gdp-wired proves all 29 with no invariant, lemma or hint written, by the same prover that proves an app's budget cap, and every proof is a certificate checked twice: by the kernel, then by Lean.

of 29 proven with nothing written, each checked by the kernel
29
Lean 4.34.0 theorems, on propext, Classical.choice and Quot.sound only
67
obligation proofs joined into the Lean theorem of MLDR, the hardest
35
broken variants refuted with a run; none ever proven
11
The 29 and real code, at 0.56. Narrated, with captions. 2:13.
Proven with nothing written, by release, each at the budget its CHANGELOG entry gives: the budgets differ, so read each row on its own.
ReleaseProvenBudget
0.3714 of 2960 s
0.3915 of 2960 s
0.4016 · 18 of 2960 s · 300 s
0.4119 of 29300 s
0.4320 of 29a 60-second counted budget
0.4419–20 of 2960 s of wall time, each protocol alone on its machine
0.4522 of 2960 s of wall time on pinned hardware, in every run (24 in some)
0.4929 of 29larger budgets than those runs, in our harness

MLDR, MongoDB's logless dynamic reconfiguration: its Lean certificate is too large to check in one build on a 32 GB machine, so it was checked as 35 obligation proofs joined into the family theorem.

11 · 11 · 7 Each protocol has a broken variant with a planted bug: 11 refuted with an actual counterexample run, 11 rejected on a small instance without a trace, 7 still open. None is proven.

10 of 10 before IC3Syn: the DistAI and DuoAI protocols (locks, leader election on a ring, consensus), all ten inside 60 s in every run at 0.33, 200 of 200 over 20 runs each.

Not claimed

  • All 29 within the reference budget (counted work equal to 600 reference CPU seconds, IC3Syn's default timeout): that result is pending, to be published as an addendum.
  • A lead over IC3Syn or the tools it measures: our budgets differ from the paper's.
  • Implementations: the proofs are of the stated laws of the protocols' models.
  • Lean checks the exported certificates; binding them to the original machines in Lean is not yet claimed.

Nothing on trust

Every answer, checked.

Proven

A certificate a small kernel checks

Every proof comes with a certificate, and a small kernel (kernel/kernel.ts) checks it. The prover that found it is untrusted: if it is wrong, the kernel refuses the proof.

Again

Re-checkable in Lean

Every proof leaves as a Lean theorem. The kernel's twin in Lean 4.34.0 is proven sound on the standard axioms, and lake build checks the proofs again.

Broken

The exact run that breaks it

A false law comes back with a real run from the start: the params and each request in order, replayed before it counts.

The benchmarks get the same treatment: on CHC-COMP every sat answer is the kernel's proof on the original rule and every unsat answer a run that checkDerivation confirms.

The same law, three ways

The proof is one line.

A request of cost c is admitted while spend s is under budget b; each request is capped at m. The law: spend stays within b + m after any sequence of requests. Real code from the repository's compare/, each one checked.

import {min, nat, proveRule, rule, when} from 'gdp-wired'

// A request of cost c is admitted while spend s is under budget b; each request is capped at m.
const budget = rule('budget')
  .params({b: nat, m: nat})
  .inputs({c: nat})
  .state({s: 0})
  .step(({b, m, c, s}) => ({s: when(s.lt(b), s.plus(min(c, m)), s)}))

// The law
const bounded = budget.law('spend stays within b + m', ({s, b, m}) => s.atMost(b.plus(m)))

// The proof
proveRule(budget, [bounded]) // {proven: true, checked: true}

Proven by induction over steps; the kernel checks the tree the prover grows. 25 ms, whole command.

Measured on the same three rules: one Modal run, 2 CPUs per job, median of 5 (source)
RuleToolProof linesCheck, median
budgetgdp-wired125 ms
Lean8488 ms
Bend84137 ms
capsgdp-wired144 ms
Lean30547 ms
Bend74161 ms
windowgdp-wired242 ms
Lean29571 ms
Bend117156 ms

Most of each check time is the tool's startup floor: 17 ms for gdp-wired, 134 ms for Bend, 453 ms for Lean. Every tool was also handed the same bug for each rule, and rejected it.

When a law is false

You get a real run that breaks it.

Forget the cap: write s.plus(c) instead of s.plus(min(c, m)). The kernel refuses the proof, and a search from the start turns the failure into a run you can replay.

Searches over short histories run on the GPU; every hit is replayed before it counts.

// the step, with the cap forgotten
.step(({b, c, s}) => ({s: when(s.lt(b), s.plus(c), s)}))

proveRule(budget, [bounded])
// refused, and a run that breaks the law:
// {params: {b: 1, m: 0}, trace: [{c: 2}]}

What it proves

Laws about state, automatically.

187 rules from 21 domains in the examples (finance, access control, public services, operations, protocols, commerce, supply chains, games, education, healthcare, energy, networking, AI agents, cloud, ad tech, governance, insurance, bookings, safety and IoT, mobility, media), each checked three ways: proven, broken by a real run, checked by Lean.

59 of 59 laws from a Bend project's policy core (jev-fabric), ported and proven automatically.

29 of 29 of IC3Syn's distributed protocols proven with nothing written, every proof checked by the kernel and again by Lean (the protocols).

Beyond the benchmarks

Real projects, real bugs.

Rules and state machines from open-source code in the languages it reads (rate limiters, quotas, ledgers, escrow, payments, sessions and OAuth, access policies, job queues, circuit breakers, feature flags, approvals), each pinned to a commit and given the laws a reviewer would ask about. At 0.32.0, where the 361 laws of 0.31 kept their verdicts (CHANGELOG):

laws checked
440
proven
391
broken, each with the run that breaks it
39
still open
10

Along the way it found real bugs in 15 open-source projects, each reported to its maintainers or already known upstream. Two were low-severity security issues, reported privately.

0.6.0 to 0.51

The climb, release by release.

Solved tasks on Modal: an early release's figure beside 0.30's (CHC-COMP from the four side-by-side batches after it; on boat now, each tool alone on 4 vCPUs, 1,159–1,169), each with its run in the CHANGELOG
BenchmarkThenNow
CHC-COMP LIA-Lin368 0.201,165–1,168
TIP 201573 0.20212–213
SV-COMP termination47 0.22246
TermComp ITS, terminates56 0.22613–614
TermComp ITS, doesn’t terminate320 0.22538–542
Real-world corpus, proven of 311218 0.23274
  1. 0.7gdp-ts proofs minted by checks gdp-wired has proven
  2. 0.8Records, variants and the lemmas you state
  3. 0.10–0.11Lists a request carries, trees, laws over 64 steps
  4. 0.12Conditions at every two keys; the prover rebuilt for speed (a 64-step law, 87 s to 5.1 s)
  5. 0.13–0.14Statecharts, and XState machines read as charts
  6. 0.15–0.16Invariants nobody wrote, found; a stuck law searches for what it needs
  7. 0.17–0.19Cyclic proofs in the kernel and in Lean, the certificate by default; recursive datatypes as values
  8. 0.20–0.21The frontier corpus, 81 of 81; “there exists”, recursion that isn't structural
  9. 0.22A CDCL search for wide steps: 332 of 332 CHC step goals, from 43
  10. 0.23Runs that never end, linear arithmetic over the rationals, the real-world corpus
  11. 0.24k-induction, rules read from TypeScript (gdp-wired/extract), SV-COMP read from C as C runs
  12. 0.25–0.26The lemma search on TIP 2015; certificates in an interchange format, with checkers outside the library
  13. 0.27–0.28A Go front end for the extractor; nontermination closed by cases
  14. 0.29Sums over a map's keys (M.sum()) and liveness under strong fairness, each proven in Lean first
  15. 0.30IMC's query made cheap (a median 1,239 ms to 81 ms on 16 gap tasks); CHC-COMP LIA-Lin reaches the leading tools, and led them by 5 in four side-by-side batches on Modal after the release (2 vCPU); measured again on boat, each tool alone on 4 vCPUs, it is level with Golem
  16. 0.31Effect services read into rules; four distributed protocols proven with nothing written; a sum's cells keep their kind, proven in Lean first
  17. 0.32Ten of ten distributed protocols with nothing written, each checked again in Lean; Java, Kotlin and Swift; npx gdp-wired-cli check, laws as comments in 11 languages
  18. 0.33All ten protocols inside 60 s in every run; counts and ghost maps as certificate kinds, proven in Lean first; fixed: the TypeScript kernel could accept a false proof past 253 (Lean re-checks were never affected)
  19. 0.33.1Fixed: a law key named k# could make the TypeScript kernel accept a false law (Lean re-checks were never affected)
  20. 0.34Liveness over every key, clocks and leases between nodes, and ordered collections: price-time priority proven on a real order book
  21. 0.35Counts in a machine's laws, proven in Lean first, and a search that finds them: three more distributed protocols proven with nothing written
  22. 0.36Exceptions and loops read from code: try/except proven for every outcome, folds over lists exact for every length
  23. 0.37Fourteen of IC3Syn's 29 distributed protocols proven with nothing written, the first through a ghost map, each checked again by Lean
  24. 0.38Solidity, with re-entrancy and 256-bit arithmetic: a DAO-shaped contract broken by a re-entrant run replayed on its bytecode, its fix proven
  25. 0.39More real Python read as it ships, a conditional store write no longer misread; fifteen of IC3Syn's 29 protocols proven with nothing written
  26. 0.40Big goals decided by asking for a model first: sixteen of IC3Syn's 29 protocols at 60 s, eighteen at 300 s
  27. 0.41OpenZeppelin's ERC-20: the sum of balances equals totalSupply, proven on the whole contract; nineteen of IC3Syn's 29 at 300 s
  28. 0.41.1Fixed: names that collide with the ones the kernel makes for itself could make the TypeScript kernel accept a false law (Lean refuses six of the seven)
  29. 0.42Faster IMC for CHC-COMP: the full bar at 1,181 solved, none wrong
  30. 0.43Effect's retries and transactions (Schedule, STM) read and proven; the CLI accounts for every law stated in the code; IC3Syn's ports checked against TLC step by step; the soundness fuzz made exact
  31. 0.44gdp-wired-check, the trusted kernel alone as its own checker (an npm bin, a 139 KB file, WebAssembly); Effect queues and semaphores; a faster CDCL search; 0.43’s package fixed
  32. 0.45Security fix: names such as constructor and __proto__ were read through the JavaScript prototype, so 0.44’s TypeScript kernel and gdp-wired-check could accept a crafted false rule or certificate (Lean re-checks never did; upgrade); TIP proven 219–221 of 492, from 209–212; “there exists” verdicts checked by the kernel; distributed apps through the CLI
  33. 0.46Fixed: Python’s round(a / k) is exact only below 252, and a strict decision rechecks its cached model; check --security proposes policies for review; database handlers over Django, SQLAlchemy, Prisma and TypeORM
  34. 0.47Effect Schema read into typed values (fromSchema: signed integers, booleans, choices, records, Maybe, tagged unions), exact on decoded closed values; unsupported predicates fail closed
  35. 0.48Breaking: source translation is cross-checked against native execution by default (unchecked laws exit 2), and fun.run() interprets terms; CI-first use: a dev dependency, plain code shipped; finite comparisons and mutation checks
  36. 0.49All 29 of IC3Syn’s distributed protocols proven with nothing written and kernel-checked, every one checked again by Lean (67 theorems); of their broken variants, 11 refuted by a run and none proven
  37. 0.50Proofs at every size: 27 of IC3Syn’s source models proven in Lean for every size, not up to a bound, and Paxos the 28th in 0.50.1 (MLDR stays proven up to size 64); gdp-wired lift turns a proof into a self-contained Lean project
  38. 0.50.2Fixed: gdp-wired-cli check exited 0 on a stated law it couldn’t settle (since 0.32; it exits 2 now), and a Lean export of a law over a list’s plain values could prove it about their positions instead (since 0.34; such laws are refused)
  39. 0.50.4Agents consult the prover while they code: gdp-wired-agent-consult, an MCP server with prove, why_not, suggest, check_change and status
  40. 0.51Machine integers: 8 to 64 bits, signed or not, overflow that wraps, saturates or traps, and floor, truncating or Euclidean division, each checked again by Lean as its own UIntN, IntN and BitVec
  41. 0.5212 of the 16 real-world laws the prover couldn’t settle are now decided: liveness through ranks and fair rings, pairwise row invariants, guards on versioned rows; a refutation can repeat a request 231 times, checked in closed form rather than replayed
  42. 0.53Totals over maps checked by the kernel: a count or sum kept per key (a Raft vote tally, an account’s pending transfers) proven natively and checked again by Lean, settling the other four
  43. 0.53.1Fixed: a law over a sum written by a reset of every key could be reported broken when it held (never proven when false); every reported run now replays on the original rule
  44. 0.54Laws that bound an item by a running total, found and proven on their own; CometBFT’s recorded-majority law proven; minimizeRun shrinks a breaking run until every request matters
  45. 0.54.1Large models no longer crash the kernel before solving: shared subterms stay shared, and the real-world laws prove in a third less time
  46. 0.54.2Fixed: a partly initialized C or C++ const table (T[64] = {[37] = 9}) was read as all zeros, so a false law could report as proven (0.46 through 0.54.1); such tables are now read exactly or refused. Upgrade if you check C or C++
  47. 0.55Totals per group proven by the kernel: a row’s charge bounded by its tag’s total, a stored message implying a positive count for its subject, each checked again by Lean
  48. 0.55.1A law the prover can’t settle alone is retried together with its neighbours, and the last real-world law falls: all 467 decided, none left unknown
  49. 0.56Opt-in C safety: write // gdp: safety and it proves no out-of-bounds access, signed overflow or division by zero, replays every failure under the sanitizers, and states the exact compiler, flags and headers it proved under

Two structures, one boundary

Win the boundary. Hand off the rest.

Where gdp-wired, Lean and Bend sit Lean is the outer region: anything you write the proof for. Inside it, gdp-wired decides laws about stateful rules automatically, fed by the run algebra and Handwired. Bend sits beside, overlapping Lean. Arrows show the handoff: every gdp-wired proof leaves as a Lean theorem, and a function proven in Lean enters the rule as facts. Lean anything you write the proof for Bend proved programs, run on GPUs gdp-wired laws of stateful rules, decided automatically proveRule(rule, laws) {proven: true, checked: true} run algebra Handwired every proof, a Lean theorem facts proven in Lean

The run algebra

Every obligation the kernel builds is one inclusion over runs, made from a few moves: start, assume, read a request, take a step. Invariants, step laws, histories, liveness, refinement and loops all reduce to it, and one Lean twin of it (SMachine) is proven sound.

Handwired

Rules compile to GPU loop programs, through a fork of Cheng Lou's Handwired: the search that finds a breaking run, and the synthesizer that finds a missing invariant or rank for the kernel to prove.

The handoff to Lean

Past the boundary are proofs a prover would have to invent: induction nobody stated, products of unknowns. Integer arithmetic with induction or products is undecidable, so no automatic prover proves all of them. Define the function in Lean, prove its facts there, and the rule uses them. Going the other way, toLean and leanProject turn every gdp-wired proof into a Lean theorem.

Why you can trust a proof

A small kernel checks everything.

Trusted

The kernel (kernel/kernel.ts) turns a rule and its laws into goals and checks a proof tree for each: case splits on linear facts, then a linear refutation at each leaf.

Untrusted

The prover that finds the trees, the builders, the runtimes and the GPU searches. If the prover is wrong, the kernel rejects the tree.

Proven

The kernel's twin in Lean 4.34.0, proven sound with the standard axioms only. The exporter sends the kernel's real trees; tampered ones compute to false.

How it works · 14 min

The long version, explained.

A 14-minute walkthrough: certificates, the kernel, why no proof to write, the frontiers.

Narrated, with captions. 15:00.

More films

More films

The short cut. 45 s, no voice: quick cuts of the real material, the board and the corpus.
The launch film. 2 min, from the launch: the rule, the law, the proof in one line.

Prove your first rule.

The CLI reads your code where it is, in any of 11 languages. The library is plain JavaScript with types: Node 20+, Bun or a browser. The skill teaches your coding agent to write rules and laws, and an MCP server lets it consult the prover while it codes.

Your language, with a worked exampleThe guide: your first proof in seven steps

Built on

Credits