StochBench

StochBench is a Lean 4 benchmark of 450 graduate stochastic-process problems, each paired with its natural-language statement. It evaluates proof agents on graduate stochastic processes. Topics include finite and countable Markov chains, martingales, stopping times, renewal processes, random walks, queues, Brownian motion, stochastic calculus, Poisson processes, and weak convergence.

The benchmark contains direct and abstracted formalizations, with explicit assumptions for each target. The informal-formal pairs can be used for autoformalization training, and checked proofs can provide supervision for proof generation. Shared definitions support further formalization in Lean.

The accompanying paper, StochBench: A Domain-Specific Benchmark for Stochastic Processes in Lean, reports 157 clean proofs out of 450 targets (34.9%) from an Opus 4.8-based agent under a 15-minute per-problem limit, with results reported by topic and representation.

Keywords: Formal theorem proving, Lean 4, stochastic processes, mathematical reasoning, natural language processing, large language models, autoformalization, domain-specific benchmarks

License: Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International; see LICENSE.txt.

Formalization scope

The true_to_source field distinguishes two representations:

• Direct (literal): 114 targets, or 25.3%. These use Mathlib objects or shared definitions to express the problem.
• Abstracted (abstract): 336 targets, or 74.7%. These supply required mathematical properties as explicit hypotheses, particularly where the development environment lacks the necessary infrastructure. The properties may define an object or provide intermediate results from the source problem.

For example, a hitting-time target may assume first-step equations for an expected hitting-time function. Proving the resulting target can require substantial mathematics while leaving the connection to pathwise hitting-time random variables outside the formalized task. The paper's Q361 example illustrates this distinction: its proof develops auxiliary results about matrix powers, harmonic functions, and hitting-time inequalities from the supplied equations.

The labels describe how a target is represented. They are curator-assigned categories rather than correctness scores or rigorously defined difficulty levels. Lean checks that a completed proof establishes its conclusion under the stated hypotheses; correspondence with the informal problem requires a separate assessment.

Coverage and baseline results

The paper evaluates a multi-turn, tool-using Opus 4.8-based agent with lean4skills and the Lean LSP MCP server. Each target received one run capped at 15 minutes, with access to compiler feedback, library and shared-definition search, loogle, leansearch, and proof revision. The same model family assisted with statement construction.

A clean proof is accepted by Lean without sorry, sorryAx, or additional admitted facts, with checking performed using Lean comparator. The following results reproduce Table 1 of the paper. Only proofs with recorded proving times of at most 900 seconds are counted.

Topic	Direct targets	Abstracted targets	Total targets	Clean proofs	Proof rate
Poisson processes	5	35	40	7	17.5%
Markov chains (finite & countable)	23	73	96	37	38.5%
Renewal processes	0	41	41	2	4.9%
Continuous-time Markov & queues	1	54	55	23	41.8%
Random walks & large deviations	9	53	62	16	25.8%
Martingales & stopping	67	27	94	58	61.7%
Brownian motion & stochastic calculus	0	45	45	8	17.8%
Weak convergence & functional limits	9	8	17	6	35.3%
Total	114	336	450	157	34.9%

The baseline proves 79 of 114 direct targets (69.3%) and 78 of 336 abstracted targets (23.2%). These are descriptive comparisons across different problems and levels of library support. They do not isolate the effect of abstraction. The evaluation covers one agent and one time budget, without repeated runs or a comparison between models.

The released attempted_proof.json contains 168 stored proofs, including 11 with recorded times above the baseline cutoff. Thus, 168 is the number of stored proof records, while 157 is the paper's count within the 15-minute budget. Q361 has a recorded lower bound of 1800 seconds and is discussed separately in the paper's appendix.

Dataset files and fields

There are 450 distinct problems with IDs 1-450. Join records using question_id, since the proof file covers only a subset of the problems. The files are overlapping views of the corpus; no separate training, validation, or test partition is provided.

• questions.json (450 records): English problem statements, names, and topics.
• statements.json (450 records): The same metadata, Lean targets, and formalization labels.
• attempted_proof.json (168 records): Matching statement metadata, stored proof declarations, and recorded proving times.
• proofs/p_<question_id>.lean (168 files): Corresponding Lean proof source files.
• helper_funcs.lean: Shared mathematical definitions in the Auto namespace.

Field	Type	Present in	Description
question_id	integer	All JSON files	Problem identifier shared across files
problem_name	string	All JSON files	Descriptive machine-readable problem name
informal_statement	string	All JSON files	English mathematical problem, including notation and hypotheses
topic	string	All JSON files	One of the eight topic labels above
lean_statement	string	Statements and proofs	Lean theorem target with an intentional sorry proof placeholder
true_to_source	string	Statements and proofs	Representation label: literal (direct) or abstract (abstracted)
proof	string	Proofs	Lean declaration containing the stored proof, including any auxiliary declarations
time_seconds	integer	Proofs	Recorded proving time in seconds
time_seconds_is_lower_bound	boolean, optional	Proofs	When true, the recorded time is only a lower bound; absent from other records

For Q361, time_seconds is 1800 and time_seconds_is_lower_bound is true, reflecting a reported duration of 30+ minutes. Preserve this distinction when analyzing runtimes. Missing optional values may appear as null when loaded into a tabular dataset.

Example record

The following is a record from questions.json:

{
  "question_id": 8,
  "problem_name": "stochastic_processes_martingale_1",
  "informal_statement": "Consider biased gambler’s ruin: at each step, the gambler gains one dollar\n        with probability p and losses one dollar with probability (1 − p).\n        Let X_n be the money in purse at time n.\n\n        Show that if p = 1/2, then (X_n) is a martingale.",
  "topic": "Martingales & stopping"
}

Loading the data

Download the JSON files from Hugging Face and read them directly with Python:

import json
from pathlib import Path
from huggingface_hub import hf_hub_download

repo_id = "IdanDavidovich/StochBench"

def read_records(filename):
    path = hf_hub_download(
        repo_id=repo_id, repo_type="dataset", filename=filename
    )
    return json.loads(Path(path).read_text(encoding="utf-8"))

questions = read_records("questions.json")
statements = read_records("statements.json")
proofs = read_records("attempted_proof.json")

statements_by_id = {row["question_id"]: row for row in statements}
proofs_by_id = {row["question_id"]: row for row in proofs}
print(statements_by_id[8]["lean_statement"])

For files already downloaded to the current directory, use json.loads(Path("statements.json").read_text(encoding="utf-8")). For reproducible experiments, pass a fixed commit hash as revision to hf_hub_download and record the Lean and Mathlib versions used.

Attribution

Idan Davidovich · Debargha Ganguly · Vikash Singh · Vipin Chaudhary
Case Western Reserve University
{idan, debargha, vikash, vipin}@case.edu

Please cite the dataset repository and the revision used in your experiments. A dataset citation is:

@misc{davidovich2026stochbench,
  author = {Davidovich, Idan and Ganguly, Debargha and Singh, Vikash and Chaudhary, Vipin},
  title = {StochBench},
  year = {2026},
  howpublished = {Hugging Face dataset},
  url = {https://huggingface.co/datasets/IdanDavidovich/StochBench}
}

Sources and construction

StochBench combines problems written for the benchmark with exercises, lemmas, theorems, and corollaries selected from:

• Kyle Siegrist's Probability, Mathematical Statistics, and Stochastic Processes (2022).
• Hao Wu's MIT course 18.445 Introduction to Stochastic Processes (Spring 2015).
• David Gamarnik's MIT course 15.070J Advanced Stochastic Processes (Fall 2013).
• Robert Gallager's MIT course 6.262 Discrete Stochastic Processes (Spring 2011).

Problems were selected for their relevance to stochastic processes and expressed as mathematical claims with hypotheses. As described in the paper, all benchmark-specific questions, definitions, and hypotheses are human-written. An Opus 4.8-based formalizer assisted with expressing them as Lean theorem statements, which were revised using Lean feedback until they elaborated in Lean 4.30.0 with a fixed Mathlib version.

Shared definitions give related problems a common mathematical representation. These include matrix-based descriptions of Markov chains, first-step equations for hitting and return times, and definitions connecting stochastic-process properties to Mathlib. The definitions and hypotheses were reviewed against the source problems.