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

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.

License

This dataset is released under CC BY 4.0. Individual formalizations may inherit licenses from their upstream sources (Mathlib, Archive of Formal Proofs, HOL Light core, MathComp, miniF2F).