MathlibPR

MathlibPR is built from real Mathlib4 pull request histories and evaluates merge-readiness judgments for build-passing snapshots. Each snapshot has a binary reference label, but evaluated systems may return one of three final verdicts: merge_ready, not_merge_ready, or uncertain.

Dataset Summary

• Full benchmark size: 15,895 snapshots
• Label distribution: 11,409 merge_ready, 4,486 not_merge_ready
• Within-PR pair dataset: 3,687 pairs
• Repository-scanning subsets: six released 500/500 agent-stage subsets

This benchmark is not a compilation benchmark. All benchmark examples are already build-passing by construction. The task is to distinguish code that merely builds from code that is ready to be integrated into Mathlib4.

Task Definition

Each example has a snapshot-level binary reference label:

• merge_ready
• not_merge_ready

The not_merge_ready label is attached to the selected snapshot, not to the pull request as a whole. A PR may later evolve into an accepted final snapshot even if an earlier build-passing snapshot is labeled not_merge_ready.

Evaluated systems may output:

• merge_ready
• not_merge_ready
• uncertain

where uncertain is a valid abstaining verdict rather than a gold label.

Stages

• stage1 Diff, changed-file context, first-order import context, and guideline digests.
• stage2 Stage 1 plus structured diagnostics about linting, imports, declaration placement, documentation, and API fit.
• stage3 Stage 2 plus PR title and PR description as stated author intent.

Dataset Structure

Full benchmark configs:

• stage1
• stage2
• stage3

Balanced subset configs:

• codex_stage1_500_500_seed42
• codex_stage2_500_500_seed42
• codex_stage3_500_500_seed42
• claude_stage1_500_500_seed42
• claude_stage2_500_500_seed42
• claude_stage3_500_500_seed42

These six configs match the finalized agent result packages directly. Some of the underlying memberships overlap substantially, but the release keeps them separate so each agent-stage evaluation can be referenced without ambiguity.

Pairwise config:

• pairs Within-PR pairs consisting of one earlier build-passing snapshot labeled not_merge_ready and one final accepted snapshot labeled merge_ready.

Supporting release files:

• prompts/
• schemas/
• eval/
• metadata/
• docs/
• croissant/
• artifacts/

Loading

from datasets import load_dataset

stage3 = load_dataset("YOUR_ORG/mathlibpr", "stage3", split="test")
pairs = load_dataset("YOUR_ORG/mathlibpr", "pairs", split="test")

Balanced subset example:

codex_stage2 = load_dataset(
    "YOUR_ORG/mathlibpr",
    "codex_stage2_500_500_seed42",
    split="test",
)

codex_stage3 = load_dataset(
    "YOUR_ORG/mathlibpr",
    "codex_stage3_500_500_seed42",
    split="test",
)

claude_stage3 = load_dataset(
    "YOUR_ORG/mathlibpr",
    "claude_stage3_500_500_seed42",
    split="test",
)

Reproducing the Benchmark Input

The files in data/full/ and data/subsets/ are the benchmark manifests. The full benchmark is stored as small JSONL shards under data/full/stage1/, data/full/stage2/, and data/full/stage3/ so that the repository can be hosted without Git LFS. These manifests define which snapshot is being evaluated and store the information needed to reconstruct the Stage 1, Stage 2, or Stage 3 input. They are not pre-rendered prompts.

To reproduce the LLM model input exactly, use:

python eval/materialize_llm_model_prompt_context.py \
  --dataset data/full/stage3 \
  --stage 3 \
  --api-eval-root /path/to/api_eval_harness \
  --repo-root /path/to/mathlib4 \
  --output /tmp/stage3_materialized.jsonl

This matters because the manifests retain some source metadata that is useful for reconstruction but are not meant to be shown to the model at every stage. Stage-specific visibility is enforced by the evaluation code.

For stage2 and stage3, the release manifests already include release-facing diagnostics summaries. The helper script above is still needed to reconstruct diff context, changed-file context, and import context.

Data Fields

Core manifest fields include:

• sample_id
• pr_number
• target_merged
• snapshot_role
• snapshot_commit_sha
• diff_base_sha
• source_commit_seq
• selection_diff_path
• pr_title
• pr_description

Stage-dependent fields include:

• linter_diagnostics
• import_diagnostics
• location_diagnostics
• doc_diagnostics
• api_diagnostics

Here api_diagnostics is a catch-all field for recovered checks that do not fall into the lint/import/location/documentation buckets.

The pairs config additionally includes:

• pair_id
• earlier_sample_id
• final_sample_id
• earlier_label
• final_label

The directory metadata/source_manifest_full/ provides sample-level metadata for the full 15,895-example benchmark. The subset-level metadata files are:

• metadata/codex_stage1_500_500_seed42.jsonl
• metadata/codex_stage2_500_500_seed42.jsonl
• metadata/codex_stage3_500_500_seed42.jsonl
• metadata/claude_stage1_500_500_seed42.jsonl
• metadata/claude_stage2_500_500_seed42.jsonl
• metadata/claude_stage3_500_500_seed42.jsonl

These files are intended for auditing and reconstruction, not as model input.

Diagnostics Representation

For stage2 and stage3, the public release stores recovered check information directly in the manifest fields:

• linter_diagnostics
• import_diagnostics
• location_diagnostics
• doc_diagnostics
• api_diagnostics

When historical GitHub check records are available, those records are copied into the corresponding diagnostics fields in compact text form. When a sample only has a locally reconstructed lint summary, the release stores a normalized linter_diagnostics entry with the toolchain and affected modules, but omits long raw build traces from the reconstruction environment.

For accepted final snapshots that do not have recovered historical check records, the release uses a normalized success-style linter_diagnostics summary so the public manifests do not expose spurious local reconstruction failures.

Evaluation Metrics

The main evaluation metrics used with this benchmark are:

• AUROC
• merge_ready recall
• not_merge_ready recall
• balanced accuracy
• valid-output rate

When predictions use a third verdict such as uncertain, that verdict is treated as an error for class-recall and balanced-accuracy calculations unless an analysis explicitly defines a different derived metric.

Evaluation Settings

MathlibPR supports:

• LLM models
• repository-scanning LLM agents

The same benchmark is used in both settings, but the runtime interface is different. LLM models receive only the staged prompt input. LLM agents may additionally inspect a read-only local checkout at the corresponding snapshot. See docs/evaluation_modes.md.

Intended Use

This benchmark is intended for research on:

• automated code review
• formal mathematics tooling
• theorem-proving assistants
• merge-readiness evaluation

Out-of-Scope Use

MathlibPR should not be interpreted as:

• a complete model of human maintainer judgment
• a benchmark for author identity, reviewer identity, or merge-timeline prediction
• a direct benchmark of raw Lean compilation ability

Limitations

• Labels are historical outcome labels derived from real Mathlib4 PR trajectories, not perfect oracle annotations.
• A not_merge_ready snapshot may reflect revision timing, review iteration, abandonment, or evolving maintainer expectations, not only local code quality.
• Repository-scanning agent results are currently on balanced subsets rather than the full 15,895 example benchmark.
• Reproducing the LLM model input exactly still depends on a local Mathlib repository checkout.

Additional release notes are in docs/limitations.md and docs/responsible_ai.md.

Licensing and Attribution

This release is distributed under Apache-2.0. It contains code snippets and diffs derived from Mathlib4, which is distributed under the Apache License 2.0.

Additional attribution notes are in NOTICE.

Running the Benchmark

The files in eval/ provide helper scripts for pair construction, metadata generation, diagnostics compaction, input reconstruction, and scoring. They do not themselves launch a model server.

For fresh inference runs, use the companion evaluation harnesses:

• LLM models: companion api_eval_harness
• Codex agent runs: companion codex_eval_harness
• Claude Code agent runs: companion claude_eval_harness

For LLM model inference:

• If you use a hosted API provider, you do not need to start local vLLM because the model is already being served remotely by that provider.
• If you use a local OpenAI-compatible provider for an open-weight model, you should start vLLM first and point the provider config at that endpoint.
• In our own open-weight LLM model runs, local OpenAI-compatible serving was commonly used, so starting vLLM was often part of the actual evaluation workflow.

Generic vLLM example:

vllm serve YOUR_MODEL \
  --host 127.0.0.1 \
  --port 8000

The LLM model harness should then target http://127.0.0.1:8000/v1. This matches the OpenAI-style serving mode documented by vLLM: https://docs.vllm.ai/en/latest/serving/openai_compatible_server/

Artifacts

The benchmark package does not include full raw prediction dumps. It does include small paper-facing artifacts in artifacts/:

• table3_metrics_scheme_a_from_completed_runs.csv
• table4_stage3_prediction_breakdown.csv
• table5_within_pr_pairwise.csv
• uncertain_reason_summary.csv

These are summary artifacts only, not benchmark inputs.

Croissant and NeurIPS E&D

NeurIPS 2026 E&D requires a hosted dataset URL plus a validated Croissant file containing both core metadata and minimal Responsible AI (RAI) metadata. Hugging Face automatically generates the core Croissant file for supported dataset repos, but the RAI fields still need to be added manually.

This release includes:

• croissant/rai_fields.json

The intended workflow is:

1. upload the dataset repo to Hugging Face
2. download the auto-generated Croissant file from the dataset URL
3. merge in the dataset-level RAI fields from croissant/rai_fields.json
4. validate the completed Croissant file
5. submit the dataset URL and validated Croissant file to OpenReview

If Hugging Face is used as the hosting platform, NeurIPS 2026 hosting guidance currently expects the dataset to be publicly shared at submission time.

Citation

Citation metadata is provided in CITATION.cff.

Quick Start

Build within-PR pair data:

python eval/build_within_pr_pairs.py \
  --manifest data/full/stage3 \
  --output data/pairs/within_pr_pairs_full.jsonl

Build metadata:

python eval/build_metadata_manifest.py

Evaluate a prediction file or run directory:

python eval/evaluate_predictions.py \
  --manifest data/full/stage3 \
  --predictions /path/to/run_dir \
  --pairs data/pairs/within_pr_pairs_full.jsonl