Graviterra
Research previewv1.17 · MIT

Ensemble Prover

Language models search and propose.
Lean decides.

An autonomous mathematical workspace. Follow the approach, inspect the helpers, and take the Lean proof with you.

Open source. Runs locally. Your choice of models.

Inside the workspace
Proof graph in Ensemble Prover: selecting a helper reveals its Lean statement and proof. Open the full-size image.
Select a helper. Read the mathematics.
Actual interface, illustrative example records.
672Putnam problems with saved solutionsCumulative across models · October 7, 2026
Lean 4Proofs you can inspectExplore the proof walkthrough
MITOpen-source orchestrationExplore the source

Work with the mathematics

See what moves
the proof forward.

From the next unresolved obligation to the final certificate, the search leaves work you can examine and build on.

01 / Understand the bottleneck

Know what is blocking the proof.

The Mathematical focus panel connects the active approach, blocking obligation, last expensive action, and recorded reason for the next choice.

Explore proof search ↗
02 / Keep alternatives alive

Give another approach room to develop.

Adaptive frontier control keeps separate approaches and research questions in play. It reserves exploration alongside work that advances the original theorem.

Configure adaptive research ↗
03 / Build on checked work

Make a useful lemma useful again.

Retrieve mathematical declarations and restore compatible checked helpers. Optional mathematical memory records applications and outcomes across problems.

Explore mathematical memory ↗

One problem. An inspectable argument.

From a local estimate
to the whole theorem.

A walkthrough of an actual Putnam 1962 A4 run, using its recorded search and exported Lean proof.

  1. A direct attempt leaves work to do.

    The run restores previously checked helpers. Its initial root tactic attempt does not close the theorem; the search continues with a planned helper obligation.

  2. Extend the estimate in both directions.

    The forward bound covers points to the right. For points to the left, the proof applies it to the reflected function g(t) = f(−t). Lean accepts the resulting two-sided estimate.

    Inspect the helper in Lean
    theorem mini_putnam_1962_a4_two_sided_taylor_remainder_p1_c1_v1 : ∀ (f : ℝ → ℝ) (a b : ℝ), Differentiable ℝ f → Differentiable ℝ (deriv f) → (∀ t ∈ Set.Icc a b, |iteratedDeriv 2 f t| ≤ 1) → ∀ x ∈ Set.Icc a b, ∀ y ∈ Set.Icc a b, |f y - f x - (y - x) * deriv f x| ≤ (y - x) ^ 2 / 2 := by
      intro f a b h1 h2 hb x hx y hy
      by_cases hxy : x ≤ y
      · have ht := mini_putnam_1962_a4_taylor_forward_bound_p1_c2_v1 f a b h1 h2 hb x (y - x) hx.1 (sub_nonneg.mpr hxy) (by linarith [hy.2])
        simpa only [add_sub_cancel] using ht
      · let g : ℝ → ℝ := fun t => f (-t)
        have dg : deriv g = fun t => -deriv f (-t) := by
          funext t
          exact deriv_comp_neg f t
        have hg1 : Differentiable ℝ g := h1.comp differentiable_neg
        have hg2 : Differentiable ℝ (deriv g) := by
          rw [dg]
          exact (h2.comp differentiable_neg).neg
        have ddg (t : ℝ) : deriv (deriv g) t = deriv (deriv f) (-t) := by
          rw [dg]
          simpa using (((h2 (-t)).hasDerivAt.comp t (hasDerivAt_id t).neg).neg).deriv
        have hgb : ∀ t ∈ Set.Icc (-b) (-a), |iteratedDeriv 2 g t| ≤ 1 := by
          intro t ht
          have hf := hb (-t) (show -t ∈ Set.Icc a b from ⟨by linarith [ht.2], by linarith [ht.1]⟩)
          rw [iteratedDeriv_succ, iteratedDeriv_one] at hf ⊢
          rw [ddg]
          exact hf
        have ht := mini_putnam_1962_a4_taylor_forward_bound_p1_c2_v1 g (-b) (-a) hg1 hg2 hgb (-x) (x - y) (by linarith [hx.2]) (by linarith) (by linarith [hy.1])
        rw [show -x + (x - y) = -y by ring, dg] at ht
        simp only [g, neg_neg] at ht
        convert ht using 1 <;> ring_nf
  3. Connect the helper to the original goal.

    Choose a length-2 subinterval containing x. Apply the estimate at both endpoints; their squared distances from x sum to at most 4. Together with the bounds on f, this gives |f′(x)| ≤ 2.

    Inspect the final proof in Lean
    theorem putnam_1962_a4 : ∀ (f : ℝ → ℝ) (a b : ℝ), Differentiable ℝ f ∧ Differentiable ℝ (deriv f) → (∀ x ∈ Set.Icc a b, |f x| ≤ 1) → (∀ x ∈ Set.Icc a b, |iteratedDeriv 2 f x| ≤ 1) → b - a ≥ 2 → ∀ x ∈ Set.Icc a b, |iteratedDeriv 1 f x| ≤ 2 := by
      intro f a b hd hf hf2 hab x hx
      obtain ⟨hax, hxb⟩ := hx
      have hend : ∃ p : ℝ, a ≤ p ∧ p ≤ x ∧ x ≤ p + 2 ∧ p + 2 ≤ b := by
        by_cases h : x ≤ a + 2
        · exact ⟨a, le_rfl, hax, h, by linarith⟩
        · refine ⟨x - 2, ?_, ?_, ?_, ?_⟩ <;> linarith
      obtain ⟨p, hap, hpx, hxq, hqb⟩ := hend
      have hp : p ∈ Set.Icc a b := ⟨hap, by linarith⟩
      have hq : p + 2 ∈ Set.Icc a b := ⟨by linarith, hqb⟩
      have ht := mini_putnam_1962_a4_two_sided_taylor_remainder_p1_c1_v1
        f a b hd.1 hd.2 hf2 x ⟨hax, hxb⟩
      obtain ⟨hrpl, hrpu⟩ := abs_le.mp (ht p hp)
      obtain ⟨hrql, hrqu⟩ := abs_le.mp (ht (p + 2) hq)
      obtain ⟨hfpl, hfpu⟩ := abs_le.mp (hf p hp)
      obtain ⟨hfql, hfqu⟩ := abs_le.mp (hf (p + 2) hq)
      have hsq : (p - x) ^ 2 + (p + 2 - x) ^ 2 ≤ 4 := by
        nlinarith [mul_nonneg (sub_nonneg.mpr hpx) (sub_nonneg.mpr hxq)]
      have hd_bound : |deriv f x| ≤ 2 := by
        apply abs_le.mpr
        constructor <;> nlinarith
      simpa only [iteratedDeriv_one] using hd_bound
  4. Export the complete proof.

    The exported file contains the theorem and the helpers it uses. Lean checks the assembled result, with an axiom audit before certification.

The code excerpts come directly from the exported Lean proof. This run reused earlier checked work. Results and evaluation scope ↗

Choose your starting point

Bring the mathematics you have.

A formal target

Prove a Lean theorem.

Point the prover at a declaration, a file of unfinished theorems, or a PutnamBench problem. Search against the exact formal statement.

Start from Lean ↗

English or LaTeX · Experimental

Formalize mathematics.

Translate a claim or develop a larger body of notes into Lean. Inspect the proposed statements, then attempt proofs of the formalized claims.

Start from a claim ↗

An open question · Experimental

Investigate a problem.

Pursue approaches, intermediate conjectures, and counterexamples. With a Lean project, promising claims can move into formal proof search.

Start a research run ↗
All nine input routes, including saved work
A Lean theorem ↗

Name one declaration in a Lake project. Only its statement counts; any existing proof body is ignored.

A Lean file or folder ↗

Point it at a directory. It finds every unfinished theorem and works through them in turn. Add --check-input to validate everything without calling a model.

A theorem with an open answer ↗

A statement with an answer(sorry) slot. It proposes and reviews a candidate answer, then attempts a Lean proof of the resulting statement.

A PutnamBench problem ↗

Load a PutnamBench file directly, or sweep every unsolved problem in random order. Official answers stay hidden from the model by default.

One claim in English or LaTeX ↗

It proposes a Lean translation, type-checks it, then attempts a proof. Use --formalize-only to review the translation before paying for a proof. Lean checks the proof, not the translation.

Longer notes or a paper ↗

Supply documents and a goal. A resumable campaign decomposes the work, reviews proposed statements, proves the pieces, and checks separately compiled Lean modules.

An open problem ↗

Write the exact question, with no proof and no Lean statement. Autonomous research pursues proofs, counterexamples, and intermediate conjectures, and formalizes candidates when given a Lake project.

Claims you track yourself ↗

A ledger of claims, arguments, reviews, and dependencies, for work done by you or by outside workers. It needs neither Lean nor an API key.

A saved run ↗

Hand an earlier run to research, or resume an interrupted attempt from its checkpoint.

Prefer the browser? Launch English or Lean attempts from the local workspace. Browser setup ↗

See the launcher and results library

Your project. Your models. Your limits.

Open orchestration, all the way through.

A search you can follow.

Plans become helper obligations. Candidates go through Lean, and concrete errors guide repair. A completed proof is exported and checked against the intended theorem, project, and axiom policy.

  1. Plan
  2. Retrieve
  3. Prove
  4. Repair
  5. Export

Time, provider-call, and API cost controls bound the work. Checkpoints and recorded artifacts let you inspect or resume it. Formalization proposals and research arguments remain open to mathematical review.

Choose the model for each role.

  • LocalCompatible inference servers on your hardware.
  • APIOpenAI, DeepSeek, OpenRouter.
  • CLICodex, Claude Code, Cursor.

Configure prover, refiner, and planner roles independently. The workspace runs locally; selected providers and enabled research tools can make external requests. Provider setup ↗

Start with one theorem

See where the mathematics leads.

Linux · Python 3.11 or 3.12 · A Lean project · Your model access

Built on open mathematics:LeanMathlibPutnamBenchBenchmark paper