Back to Rankings

Foundational Refinement Proofs for Deployed Bytecode, at the Price of Tokens

Lefteris Lazaropoulos, Zoe Paraskevopoulou

Jul 28, 2026arXiv:2607.26306v1
cs.PL
Share
Scorecard· 16/16
8.0/10 impact

Novel foundational framework plus a credible demonstration that LLMs invert verification economics in a high-value domain, tempered by proprietary-model dependence and an enlarged trusted base.

Abstract

Relating low-level executable code to a high-level account of its behavior has been a central concern of programming-language research for decades. From formally verified compilers to translation validators, certifying compilers, and proof-carrying code, each approach chooses between laborious but foundational mechanized proofs and automation that costs completeness, generality, and an increased trusted base. Recently, large language models (LLMs) have begun to change the economics of formal verification. Agentic proof development is now capable of producing machine-checked proofs at a scale and speed that were previously out of reach. In this paper, we evaluate the capabilities of LLMs to produce foundational, machine-checked proofs of refinement between executable code and its high-level specification, as post hoc, per-artifact certificates. We study this in the context of the Ethereum Virtual Machine (EVM), a low-level virtual machine that executes smart contracts on the Ethereum blockchain. We build EquiVM, a foundational framework in Lean comprising an executable EVM semantics and a specification language that characterizes the intended behavior of smart contracts, but commits to no source language or compilation toolchain. In EquiVM, refinement is stated for deployed bytecode of arbitrary provenance, interaction with unknown code is part of the semantics, and each proof is a replayable, machine-checked certificate. No previous technique achieves this combination. Using frontier commercial LLMs, twenty-three real-world contracts are proved end to end with minimal human guidance, among them most of the MakerDAO stablecoin system, at up to a hundred million tokens and a hundred hours of proof time per contract. We conclude that foundational mechanized proofs can now be bought at the price of tokens, and that this shift can reshape how verification frameworks are architected.

AI Impact Assessments

(1 models)

Scientific Impact Assessment

Core Contribution. This paper introduces EqiVM, a Lean-based framework for producing *foundational, machine-checked refinement proofs* between deployed EVM bytecode and high-level specifications, with proofs synthesized by LLM agents. The central problem it addresses is a decades-old tradeoff in relating low-level code to high-level behavior: verified compilers, translation validators, and proof-carrying code each sacrifice at least one of generality, automation, or a small trusted base. EqiVM claims to achieve all three simultaneously *for bytecode of arbitrary provenance* — no source language, compiler, or toolchain cooperation required — by (1) defining an executable EVM semantics and a Solidity-mirroring specification language (Sol−) that commits to no compiler, (2) stating refinement over complete transactions with unknown-code interaction folded into the semantics via a multi-language-style external-call boundary, and (3) delegating the actual proof labor to frontier LLM agents whose output the Lean kernel checks (so the agent need not be trusted). The empirical thesis — "foundational proofs can now be bought at the price of tokens" — is demonstrated by proving 23 real deployed contracts, including most of MakerDAO.

Methodological Rigor. The design is careful and self-aware. Proofs are kernel-checked, and the trusted computing base is explicitly enumerated: the EVM model (conformance-tested at 99.99%), the refinement relation's fidelity, the Lean kernel, an opaque Keccak FFI, per-contract selector facts, and — notably — `native_decide` axioms used for large computations. The authors are commendably honest about these trust compromises and about intentional under-specification (gas, substate, revert payloads not modeled, and vacuous equivalence under gas exhaustion). The external-call boundary construction, where the specification-side and bytecode-side calls instantiate the *same* Θ function so results coincide "by construction," is an elegant and sound way to obtain interoperation without a linking theorem. Weaknesses: cost figures are approximate (subscription rather than metered API), two of the hardest contracts remain incomplete, and one genuine semantic mismatch (dynamic-array byte-count wraparound) required patching the refinement relation with a well-formedness hypothesis — an honest but scope-narrowing move.

Potential Impact. The application domain is high-value: smart contracts control large sums, bytecode is immutable (one proof holds for life), and no verified EVM compiler exists while solc has a documented miscompilation record. A foundational, compiler-independent certificate that transfers auditing scrutiny to a readable specification is directly valuable to the smart-contract security industry (auditors, Certora/hevm-style tooling vendors). Beyond the domain, the paper makes a broader claim likely to resonate across the verification community: that LLM economics invert the traditional cost model, and that *verification frameworks should be re-architected for machine, not human, proof authors*. This meta-point could influence how PL researchers design proof libraries and specification languages going forward.

Timeliness & Relevance. Extremely timely. It sits at the confluence of a genuine methodological wave (agentic proof development, following Ioannidis et al., Paraskevopoulou, Verity, Axon) and a mature applied need (bytecode-level smart-contract verification). It arrives as frontier models cross a capability threshold that makes 76k-line proofs feasible.

Strengths.

  • Genuinely novel *combination*: first framework simultaneously foundational, compiler-agnostic, and interoperating with unknown code, plus the first use of LLMs for per-artifact refinement proofs of this kind.
  • The multi-language external-call boundary is a real conceptual contribution independent of the LLM angle.
  • Rigorous scale demonstration on real deployed code (MakerDAO, WETH9, Nouns), across three compiler generations, Vyper, and hand-written assembly.
  • Detailed, transparent telemetry and failure analysis (including verbatim human prompts), which materially aids assessment.
  • A reusable proof library (reach invariant, 112 combinators) shaped as infrastructure others can extend.
  • Limitations & Gaps.

  • The empirical results depend on closed commercial models whose behavior is neither reproducible nor stable; the authors themselves flag dependence on vendor-controlled models.
  • The trusted base, while foundational in principle, is enlarged in practice by `native_decide` and FFI Keccak, weakening the "small trusted base" claim somewhat.
  • Cost is high (~$1,380 and up to 100 hours per large contract), and two hardest targets stalled — scalability limits are real.
  • Gas, events, and revert payloads are unmodeled, so "full functional equivalence" is qualified.
  • Generalization beyond EVM is asserted but not demonstrated.
  • Other observations. The paper is a system/framework + empirical evaluation hybrid. Its lasting value likely lies as much in the *architectural thesis* (design verification frameworks for LLM proof authors) and the reusable Lean framework as in the specific numbers, which will date quickly as models improve. Reproducibility of the *artifacts* (checkable certificates) is strong even though reproducibility of the *generation process* is weak.

    Overall, this is a high-impact, forward-looking paper that plausibly marks an inflection point in how a subfield approaches a long-standing barrier, tempered by dependence on proprietary models and a not-yet-minimal trusted base.

    Rating:8/ 10
    Significance 8Rigor 7.5Novelty 8.5Clarity 8

    Generated Jul 30, 2026

    Comparison History (0)

    No comparisons yet.