INSIDE THE LAB

ML-VIC-001 / RESEARCH CASE / EDITION 1.0

VICKREY
AUCTION.

Two bids. One winner.
A precise, checkable boundary.

How do you connect an auction’s rules to the code that computes its result? This case documents a saved check of one small auction core — and makes clear what that check does and does not cover.

Recorded verificationNot an independent audit. No fresh Lean or Anvil run for this publication.

OUTCOME MODEL / NO RESERVE
COMPARE / PICK HIGHER BID
WINNERParticipant 0
PRICE5units

Illustrative outcome calculation in integer units, not ETH deposits. Ties go to participant 0, including 0 / 0. Winner pays min(b0, b1); loser pays zero. No funds move. Not a new proof run.

INTERACTIVE EXPLANATION, NOT PROOF EXECUTION

OVERVIEW

A small core.
A specific job.

The higher bidder wins one item and pays the lower bid. If both bids are equal, participant 0 wins. There is no reserve price.

Source: Model.lean / auction ↗Status: Recorded evidence; not independently rerun

It computes an outcome. It doesn’t move assets.

The core returns the winner and payment amount. It does not hold funds, transfer ETH or transfer ownership of the item. Those responsibilities belong to a separate system.

The economic results assume two participants with nonnegative private values, utility equal to value received minus payment, and actual enforcement of the modeled payment and item transfer. They consider one participant changing their own bid — not collusion or a complete commit/reveal protocol.

Source: Record / mechanism + formal_scope ↗Status: Recorded evidence; not independently rerun

b0 ≥ b1

Participant 0 wins; price = b1.

b0 < b1

Participant 1 wins; price = b0.

VERIFIED PROPERTIES

What the saved
check reports.

11 groups explain the result from auction rules to exact runtime. Each has its own scope. Open a group for the exact statement, theorem names and source.

“Verified Properties” describes the supplied recorded check, not a new verification performed by this website. C01–C06 concern the economic model; later groups concern encoding and execution. The 11 groups are not a percentage of protocol security.

C01

One winner, including ties

There is always one winner. A tie goes to participant 0.

+

EXACT SCOPE / mathematical_model

Exactly one participant wins; participant 0 wins when bids are equal.

Vickrey.allocation_uniqueVickrey.allocation_rulesVickrey.tie_to_zero

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C02

The correct second price

The higher bidder wins and pays the lower bid, not its own bid.

+

EXACT SCOPE / mathematical_model

The winner pays min(b0, b1); the loser pays 0.

Vickrey.payment_correct

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C03

Truthful bidding (DSIC)

Under the stated economic assumptions, changing your own bid away from your value cannot improve your utility over truthful bidding.

+

EXACT SCOPE / mathematical_model

A truthful bid weakly dominates any unilateral deviation for every rival bid.

Vickrey.dsicVickrey.dsic_bounded

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C04

Nonnegative utility when truthful

With truthful bidding and the stated assumptions, the modeled value received is at least the modeled payment.

+

EXACT SCOPE / mathematical_model

A participant bidding truthfully has nonnegative utility.

Vickrey.individual_rationality

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C05

Allocation to the higher value

When bids reflect values, the item goes to a participant who values it most.

+

EXACT SCOPE / mathematical_model

Under truthful bidding, welfare equals max(v0, v1).

Vickrey.welfare_maximizationVickrey.welfare_dominates_allocation

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C06

Balanced model accounting

The abstract payment accounting balances. The core does not actually move funds.

+

EXACT SCOPE / mathematical_model

Participant transfers plus seller revenue sum to zero; this is not a proof of ETH transfers.

Vickrey.accountingVickrey.utility_accounting

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Economics.lean ↗Status: Proof reported in pinned repository; saved check passed

C07

Encoding and bounded values

The input and output use fixed-size encodings, and accepted bids are unsigned values below 2^128.

+

EXACT SCOPE / abi

Two 32-byte words; bids and price stay in the bounded domain.

Vickrey.word_exactVickrey.word_orderVickrey.input_sizeVickrey.output_sizeVickrey.abi_word_roundtripVickrey.price_in_range

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Abi.lean ↗Status: Proof reported in pinned repository; saved check passed

C08

Structured AST and Yul execution

The selected structured program is linked to the auction model. The number 128 counts source-interpreter steps; it is not a gas budget.

+

EXACT SCOPE / structured_ast_and_yul

The selected structured AST is related to the model for every valid bid; source fuel = 128, not gas.

Vickrey.structured_ast_decodes_exactlyVickrey.settlement_refinement

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The declaration source is not among the 15 supplied excerpts; its presence and successful check are reported by the pinned record.

Source: record.en.json / C08 ↗Status: Proof reported in pinned repository; saved check passed

C09

Compilation to the exact bytes

The recorded proof connects the selected compiler pipeline to these exact runtime bytes, rather than assuming compilation is correct.

+

EXACT SCOPE / compiler

The real compiler endpoint premises, stack checks and runtime-byte equality are discharged.

Vickrey.compiler_certificate

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/SettlementProof.lean ↗Status: Proof reported in pinned repository; saved check passed

C10

Execution of the exact runtime

From the specified fresh ABI frame, the exact code returns the right encoded result or runs out of gas. No gas limit guaranteeing success is proven.

+

EXACT SCOPE / evm_fresh_frame

With sufficient logical interpreter fuel: the exact encoded auction outcome or actual OutOfGas.

Vickrey.settlement_runtime

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/SettlementProof.lean ↗Status: Proof reported in pinned repository; saved check passed

C11

Invalid-input rejection in Yul

Bad inputs are rejected in the specified Yul model. This is not an all-cases guarantee for the gas-charged EVM runtime.

+

EXACT SCOPE / yul_only

An empty revert at the Yul layer when calldata.size < 2^256; not a universal rejection theorem for the EVM runtime.

Vickrey.admissible_invalid_input_refinement

Source status: PROOF_PRESENT_IN_PINNED_REPOSITORY; RECORDED_CHECK_PASSED

This is the source’s recorded status, not a new Lean run. The local excerpt preserves the original declaration; imported dependencies are not all included.

Source: Vickrey/Admissibility.lean ↗Status: Proof reported in pinned repository; saved check passed

TRUTHFUL BIDDING IS WEAK DOMINANCE UNDER THE MODEL ASSUMPTIONS. IT DOES NOT GUARANTEE EVERY STRATEGY IS SAFE OR EVERY DEVIATION IS STRICTLY WORSE.

VERIFICATION SCOPE

Follow the chain.
Keep the boundary.

The recorded proof connects the chosen structured program to its exact runtime and execution in a specified fresh frame.

RECORDED SCOPE / C01–C06 · Economics.lean

Define who wins and what the winner pays. Under the stated assumptions, the record also covers truthful bidding and utility.

Correct encoded resultOROutOfGas

Explore the explanation; this animation does not execute the compiler, EVM or Lean proof checker.

Source: EvmRefinementGoal.lean + SettlementProof.lean ↗Status: Recorded evidence; not independently rerun

THE RUNTIME GUARANTEE, IN PLAIN ENGLISH

The right encoded outcome.
Or OutOfGas.

For valid bids, from the specified fresh ABI frame and with enough logical interpreter fuel, the runtime either returns the exact auction result or satisfies the actual OutOfGas semantics. This does not prove a gas limit that guarantees success. Logical interpreter fuel and EVM gas are separate quantities.

Source: Vickrey.settlement_runtime : ExactRuntimeGasfulSettlement ↗Status: Recorded evidence; not independently rerun

The selected execution frame

  • Runtime bids: Fin (2^128); model bids: Nat; utility: Int.
  • Exactly 64 input bytes: two big-endian uint256 words, each value below 2^128. No function selector; msg.value = 0.
  • Exactly 64 output bytes: winner index and payment. Compiler target: Cancun.
  • The starting state is freshGasfulEntry, not an arbitrary transaction or deployed contract state.

Source: Abi.lean + record / runtime ↗Status: Recorded evidence; not independently rerun

What this result does not establish

  • Yul text to solc transformation
  • serialized JSON parsing
  • contract deployment
  • transaction-level reachability and complete Ethereum lifecycle
  • a sufficient EVM gas bound for success
  • on-chain ETH transfers
  • escrow and commit-reveal protocol incentives
  • collusion and budget constraints

Source: Record / formal_scope.excluded ↗Status: Explicitly outside the recorded guarantee

Invalid inputs have a different boundary.

The rejection result is at the Yul layer, with the assumption calldata.size < 2^256. It is not a universal invalid-input theorem for the gas-charged EVM runtime. The lengths 64 and 2^256 + 64 would otherwise alias as CALLDATASIZE.

Source: Vickrey.admissible_invalid_input_refinement ↗Status: Recorded evidence; not independently rerun

Exact Lean endpoint and trust assumptions Unchanged mathematical definition +
def ExactRuntimeGasfulSettlement : Prop :=
  ∀ (a b : Bid) (base : SourceState) (gas : EvmYul.UInt256),
    ∃ openFuel : Nat,
      let run := EvmYul.EVM.X (max openFuel (gas.toNat + 6))
        (EvmYul.EVM.D_J (Bytecode.ofList Generated.runtimeBytes)
          (EvmYul.UInt256.ofNat 0))
        (freshGasfulEntry Generated.runtimeBytes base a b gas)
      (∃ final, run = .ok (.success final (encodeOutcome (auction a.val b.val)))) ∨
        GasfulBridge.OutOfGasFrameSemantics run

The concrete compiler premises are discharged by Vickrey.compiler_certificate, rather than left as assumptions about compilation. The proof starts from an existing structured Generated.astJson value; Yul text-to-solc transformation and serialized JSON parsing are outside this boundary.

Trust remains in the Lean kernel and toolchain, the adequacy of the selected upstream EVM/Yul semantics, the economic assumptions and the declared frame. Reported allowlisted axioms: propext, Classical.choice, Quot.sound.

Three unchanged legacy parser/unbounded-calldata diagnostic targets remain UNPROVEN; they do not replace the selected verification gate. A separate experimental commit/reveal/escrow wrapper is also formally UNPROVEN; its executable tests do not extend this core proof.

Source: Original README + EvmRefinementGoal.lean ↗Status: Recorded evidence; not independently rerun

EVIDENCE

A result tied
to one commit.

A saved check is meaningful only with its inputs, date and scope. We keep the historical run separate from publication and packaging checks.

10 OCT 2026 / EUROPE–MOSCOW

Recorded local verification

VERIFIED · 22 stages · all exit codes 0. The original README also reports 293.1 seconds, 264 public theorems including helper lemmas, 1113 valid and 14 invalid Anvil cases. These are historical counts, not fresh website tests or 264 independent security guarantees.

Source: verification.json; counts in original README ↗Status: Recorded evidence; not independently rerun

20 OCT 2026 / PUBLICATION

Package identity checked

The supplied packaging record reports 15 matching original Git blob IDs and 12 included inputs matching a historical list of 115 SHA-256 values. The 157 binary runtime bytes match their recorded hash.

Source: packaging-checks.json ↗Status: Package integrity only; not proof replay

THIS WEBSITE ADAPTATION

What we checked here

PACKAGE_INTEGRITY_OK was reproduced for 29 package files, 15 originals, 12/115 historical hashes and 157 runtime bytes. Of 8 utility tests attempted here, 6 passed; Windows symlink privilege and CRLF/LF conversion prevented two from passing. Lean, Anvil and remote full-source export were not rerun.

Source: English report / adaptation checks ↗Status: Local packaging checks; no new proof check

PINNED COMMITd02ea87ce713d589c72328b89902a92d11275480

Branch: codex/verify-refinement. The original repository was private at retrieval; its main branch contains an older prototype.

TREEda1a82df7e4612091f2996fea7ffc1d8b33cb01b
RUNTIME SHA-256 / 157 BINARY BYTES5ad69bf3ad48717a7beb1a083d2229241934fd01370062bbcdf89e15ff29349eTEXT .HEX FILE SHA-256 / A DIFFERENT BYTE SEQUENCE2607c4326db51db03c769e25e905db191b582a9a17ae731411dfe0b2b28fdef5

Source: Source index + original record ↗Status: Unsigned identifiers; not authorship authentication

Hashes check consistency with an unsigned record. They are not an auditor’s signature, proof replay, keccak256 or a deployed contract address. A raw end_to_end_verified flag refers only to the record’s explicitly declared structured-AST-to-runtime scope. No hosted CI run or independent audit is established.

REPRODUCIBILITY

Three different
levels of evidence.

SUPPLIED

Recorded verification

A saved successful check for the pinned commit, with its scope and source evidence.

Available in this publication
NOT REPLAYED HERE

Reproducible proof

A new successful check using the full source, pinned dependencies and fresh logs. Instructions are provided; a new successful run is not claimed.

Full private source and dependencies required.
NOT PROVIDED

Independent audit

A separate review by an independent party. This project record is not that review and has no external auditor signature.

No independent audit claimed.

Source: Record / recorded_verification, packaging + trust ↗Status: Evidence levels kept separate

Check the original evidence package

python3 tools/verify_package.py

Run this inside the original unpacked archive, not the adapted website directory. Expected: PACKAGE_INTEGRITY_OK. It checks the unsigned package inventory, not the Lean proofs.

Obtain the full pinned source

python3 tools/build_source_bundle.py --repo-root /path/to/vickrey-lean-solidus

Requires authorized private-repository access. The tool exports the pinned commit, checks all 115 historical input hashes and 15 originals, excludes uncommitted changes and credentials, and does not run Lean. Remote export was not tested here.

Run a fresh check in the full source tree

cd vickrey-source-d02ea87
cp -R results ../recorded-results-d02ea87
cp versions.json ../recorded-versions-d02ea87.json
cp lake-manifest.json ../recorded-lake-manifest-d02ea87.json
make bootstrap
make verify

Keep the historical evidence untouched; save new logs and versions separately. Bootstrap may update lock or metadata files. A new run does not expand the verification boundary, and OutOfGas remains an allowed outcome.

This is not a complete offline proof bundle.

The package contains 15 excerpts, not every Lean import or compiler certificate. Third-party dependencies and executables are absent. Do not run make verify inside source-excerpts.

The source recommends macOS arm64, Python 3.12+, Git, Xcode CLI and elan. Cold builds need a network connection, several GB of disk and about 5 GB RAM for one certificate according to the README. Bootstrap supplies macOS arm64 tools; Linux requires solc/forge/cast/anvil in PATH and is not confirmed by this publication.

Source: English reproduction guide, translated from REPRODUCE.md ↗Status: Procedure supplied; fresh proof reproduction not performed

Lean 4.28.0solc 0.8.26+commit.8a97fa7aFoundry 1.5.1Recorded host macOS 15.3.1 arm64

Source: versions.json; full dependency revisions in lake-manifest.json ↗Status: Recorded evidence; not independently rerun

FROM A BOUNDED CORE TO YOUR MECHANISM

Start with the rules
you need to make real.

This case demonstrates a focused research boundary. Your mechanism needs its own requirements, assumptions and verification goals.

Discuss your mechanism