desargues-hf/annals-math-rl

AnnalsChallenge RL

Lean theorem-proving tasks from 50 Annals of Mathematics papers, packaged as RL environments for Harbor.

We at Desargues adapted AnnalsChallenge into Harbor environments for experiments with theorem-proving agents.

The Annals of Mathematics is one of the leading journals in mathematics. AnnalsChallenge formalizes statements of main results from 50 papers published there since 2020, using Lean 4 and Mathlib. The statements are provided without formalized proofs: completing those proofs is the challenge.

Why statement quality matters

Lean checks whether a proof establishes the supplied formal statement. If translating a paper into Lean accidentally weakens the conclusion or changes a definition, a correct proof can still miss the intended mathematics.

AnnalsChallenge's statements were formalized by hand, using Mathlib's community-reviewed definitions wherever possible. Each formalization underwent detailed human review and additional AI audits to check its correspondence with the paper. When the intended meaning was unclear, the team consulted the original authors. This gives greater confidence that agents are working on faithful formalizations of the published results. Methodology

This release packages the tasks with agent instructions, a Lean environment, and a separate submission verifier. Each paper becomes one task, with 95 missing proofs, definitions, and instances across the collection. A task earns reward 1 only when every designated target passes verification.

We were inspired by FineEnvs/openai-math and adapted its Harbor packaging and verifier infrastructure.

How a task works

The agent runs in an offline Linux sandbox with Lean and prebuilt Mathlib. The task instruction initializes /workspace from a bundled starter package. The agent edits Submission.lean and may add Lean helpers under Submission/.

Harbor collects those files and grades them in a separate fresh sandbox using trusted copies of Challenge.lean, optional ChallengeDeps.lean, and Solution.lean. The last file is a fixed bridge to the solver's declarations; it is not a reference proof. Comparator checks the original theorem and definition-hole contract with the permitted axioms propext, Quot.sound, and Classical.choice.

• Reward 1: every designated declaration is accepted by Comparator.
• Reward 0: the submitted formalization fails the check or runs out of its grading budget.

The evaluator uses FineEnvs's direct Comparator approach. Partial progress has no separate reward.

The runtime library policy is Mathlib only. The generated upstream lakefiles also allow Lean Pool for solutions; this optional dependency is omitted here. The original lakefiles remain unchanged under sources/lean-eval for provenance. Supplied task statements and starter modules do not import Lean Pool.

What's included

This release contains 50 Harbor environments with 95 proof, definition, and instance targets. Each environment includes agent instructions, a bundled Lean workspace, and a verifier that checks submissions in a separate sandbox.

The shared Docker image builds successfully, and all 50 starter packages compile. Instructions for building and running the environments are below; detailed test results are in the generator documentation.

• tasks/: 50 Harbor task directories, each with instructions, identical environment inputs, trusted task data and the verifier.
• registry.json: dataset registry entry annals-math-rl@1.0.
• manifest.json and manifest.parquet: one record per paper, including holes, upstream status, source identifiers and hashes.
• generator/: offline generator, shared image recipe, snapshot helper and packaging tests.
• sources/lean-eval/: selected upstream manifests and generated packages, copied byte for byte with a SHA-256 provenance manifest.
• sources.lock.json: pinned upstream and runtime revisions.
• LICENSE, NOTICE and LICENSE-*: licensing and attribution.

No solution/ or oracle implementation is included. This release does not assess proof availability or task solvability.

Run with Harbor

Use Python 3.12+ and Harbor 0.24 with support for schema 1.4 and separate verifier environments. Download this package with hf download desargues-hf/annals-math-rl --repo-type dataset --local-dir annals-math-rl, then change into that directory. The Daytona example requires DAYTONA_API_KEY, DAYTONA_API_URL, and credentials for the chosen agent:

python3 -m venv .venv
source .venv/bin/activate
python -m pip install -e './generator[run]'
python3 -m annals_challenge_harbor.snapshot
SNAP=$(python3 -m annals_challenge_harbor.snapshot --print-name)

harbor run -p tasks -e daytona --ek snapshot_template_name="$SNAP" \
  -a AGENT_NAME -m MODEL_NAME -i annals_random_bernoulli_matrices -n 1

The image needs Linux with Landlock support. It builds pinned Lean, Mathlib, Comparator, lean4export and landrun. Build-time downloads are required; task execution and grading run without network access. Every task's environment directory is identical, so the snapshot is shared.

Each task requests 4 CPUs, 8 GiB memory and 10 GiB storage. The agent budget is four hours. Comparator has three hours, within a verifier budget of three hours and fifteen minutes. These fixed limits describe resources, not expected proof difficulty.

Regenerate offline

python3 -m pip install -e ./generator
python3 -m annals_challenge_harbor.adapter

The default source is the vendored snapshot. Its complete file inventory and hashes are verified before generation. To initially populate the source subset from the pinned upstream checkout/archive:

python3 -m annals_challenge_harbor.adapter --source /path/to/pinned/lean-eval --out .

Generation includes exactly 50 tasks and 95 holes. It stages all starters in the shared image before copying that image into the tasks. It does not download proofs or run an oracle.

Runtime Lean is leanprover/lean4:v4.35.0-rc3; Mathlib is 5e0c4e5239cb0a2d86d68a884bf52cfd963fce22. Comparator and exporter have their own explicit build setup; consult sources.lock.json and generator/README.md for the complete pins and architecture.

Sources and task coverage

The mathematical statements originate from AnnalsChallenge at e32eb1411db0d700ca874dd695aea92f78699db8. This release preserves the supplied Lean declarations, their dependencies and their designated holes. Complete source revisions and hashes are recorded in sources.lock.json and the vendored source inventory.

All 50 Annals-tagged upstream manifests are included regardless of upstream status. Status and statement revision are preserved in task metadata; the live leaderboard's default view may show fewer tasks.

Attribution

The mathematical statements were formalized by the AnnalsChallenge team. This release was inspired by FineEnvs/openai-math and adapts its Harbor packaging and verifier infrastructure.

The source materials and adapted infrastructure are licensed under Apache-2.0. Preserve the source copyright notices and accompanying license files.

For the mathematical dataset, cite A dataset of formalised theorem statements from the Annals of Mathematics. This package is an independent environment adaptation and does not claim endorsement by those projects.