Datasets:
File size: 5,033 Bytes
59d2881 a5d0bd5 59d2881 a5d0bd5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | ---
language:
- en
- code
license: cc-by-4.0
task_categories:
- translation
tags:
- formal-verification
- theorem-proving
- interactive-theorem-provers
- lean4
- rocq
- coq
- isabelle
- hol-light
- code-translation
pretty_name: ITPEval
size_categories:
- 1K<n<10K
---
# ITPEval: Benchmarking Formal Translation Across Interactive Theorem Provers
ITPEval is a benchmark for evaluating automated formal proof translation across four major interactive theorem provers (ITPs) spanning two logical foundations. It accompanies the paper *ITPEval: Benchmarking Formal Translation Across Interactive Theorem Provers*.
## Dataset Summary
The benchmark comprises **390 aligned files** spanning over 1,700 theorems and lemmas, each formalized in all four ITPs:
| ITP | Foundation | File Extension |
|---|---|---|
| Lean 4 | Calculus of Inductive Constructions | `.lean` |
| Rocq (Coq) | Calculus of Inductive Constructions | `.v` |
| Isabelle/HOL | Higher-order logic | `.thy` |
| HOL Light | Higher-order logic | `.ml` |
Every theorem is present in all four ITPs (4-way intersection), yielding **12 balanced directed translation pairs** per file.
## Data Files
| File | Records | Description |
|---|---|---|
| `stmts.json` | 1,560 | Sorry-stripped theorem statements (390 theorems × 4 ITPs) |
| `proofs.json` | 296 | Full proof files (74 theorems × 4 ITPs) |
## Record Schema
Each record is a JSON object with the following fields:
| Field | Type | Description |
|---|---|---|
| `theorem_id` | int | Globally unique theorem identifier (1–390) |
| `title` | string | Theorem name (e.g., `"circle_average"`, `"aime_1983_p1"`) |
| `source` | string | Benchmark source: `"babel-formal"`, `"hundred-theorems"`, or `"minif2f"` |
| `tier` | string | `"a"` (controlled/axiomatized) or `"b"` (ecosystem/library-dependent) |
| `prover` | string | ITP system: `"lean4"`, `"rocq"`, `"isabelle"`, or `"hol-light"` |
| `content` | string | Full file text (statement-only for `stmts.json`, complete proof for `proofs.json`) |
| `split` | string | *(miniF2F only)* `"test"` or `"valid"` |
## Benchmark Structure
The benchmark is organized into two tiers:
| Tier | Source | Files | Lemmas | Description |
|---|---|---|---|---|
| A (Controlled) | Babel-formal | 16 | 165 | Self-contained, axiomatized theorems. Isolates foundational translation difficulty. |
| B (Ecosystem) | Hundred Theorems | 58 | 1,231 | Classical theorems from real ITP libraries. Tests library API and tactic translation. |
| B (Ecosystem) | miniF2F | 316 | 316 | Competition math statements. Tests pure statement translation. |
**Translation modes:**
- **Statement translation** (`stmts.json`): All 390 files. Source file has proof bodies replaced by placeholders (`sorry`, `Admitted`, etc.). Yields 4,680 directed pairs per model (390 × 12 directions).
- **Proof translation** (`proofs.json`): Babel-formal + Hundred Theorems (74 files). Source file contains the complete proof. Yields 888 directed pairs per model (74 × 12 directions).
## Usage
```python
import json
# Load data
stmts = json.load(open("stmts.json")) # 1,560 records
proofs = json.load(open("proofs.json")) # 296 records
# All Lean 4 statements
lean4_stmts = [r for r in stmts if r["prover"] == "lean4"]
# All 4 ITP variants of one theorem
theorem_1 = [r for r in stmts if r["theorem_id"] == 1]
# Generate all directed translation pairs for a theorem
def translation_pairs(records, theorem_id):
variants = [r for r in records if r["theorem_id"] == theorem_id]
pairs = []
for src in variants:
for tgt in variants:
if src["prover"] != tgt["prover"]:
pairs.append({"src": src, "tgt_prover": tgt["prover"]})
return pairs
# Tier A only (controlled)
tier_a = [r for r in stmts if r["tier"] == "a"]
# miniF2F test split
minif2f_test = [r for r in stmts if r["source"] == "minif2f" and r.get("split") == "test"]
```
## Evaluation Protocol
For each (source file, target ITP) pair:
1. Prompt an LLM with the source file and the target ITP name
2. The LLM generates a complete file in the target ITP
3. Run the generated file through the target ITP binary
4. Mark as **verified** if and only if the ITP exits with code 0 (no errors, no partial credit)
Per-prover timeouts: Lean 4 and Rocq at 60s, Isabelle at 120s, HOL Light at 300s.
## Key Results
With five LLMs (GPT-5.5, Claude Sonnet 4.6, Gemini 3.1 Pro, DeepSeek-V4-Pro, Qwen3-235B), evaluated zero-shot at temperature 0:
- Statement translation peaks at **29.1%** pass@1; proof translation peaks at **10.5%**
- Tier A (controlled) reaches **29.7%** proof pass@1 vs. **5.2%** for Tier B (ecosystem)
- Translation direction matters sharply: e.g., Lean 4 → Isabelle (19.8%) vs. Isabelle → Lean 4 (1.9%)
## License
This dataset is released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Individual formalizations may inherit licenses from their upstream sources (Mathlib, Archive of Formal Proofs, HOL Light core, MathComp, miniF2F). |