Dataset Card

README.md

@@ -0,0 +1,157 @@
+---
+license: cc-by-nc-sa-4.0
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- Formal theorem proving
+- Lean 4
+- Stochastic processes
+- Mathematical reasoning
+- Natural language processing
+- Autoformalization
+pretty_name: StochBench
+size_categories:
+- n<1K
+---
+# 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](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`:
+
+```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:
+
+```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:
+
+```bibtex
+@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.