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 ↗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.
Work with the mathematics
From the next unresolved obligation to the final certificate, the search leaves work you can examine and build on.
The Mathematical focus panel connects the active approach, blocking obligation, last expensive action, and recorded reason for the next choice.
Explore proof search ↗Adaptive frontier control keeps separate approaches and research questions in play. It reserves exploration alongside work that advances the original theorem.
Configure adaptive research ↗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.
A walkthrough of an actual Putnam 1962 A4 run, using its recorded search and exported Lean proof.
The run restores previously checked helpers. Its initial root tactic attempt does not close the theorem; the search continues with a planned helper obligation.
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.
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_nfChoose 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.
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_boundThe 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
A formal target
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
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
Pursue approaches, intermediate conjectures, and counterexamples. With a Lean project, promising claims can move into formal proof search.
Start a research run ↗Name one declaration in a Lake project. Only its statement counts; any existing proof body is ignored.
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 statement with an answer(sorry) slot. It proposes and reviews a candidate answer, then attempts a Lean proof of the resulting statement.
Load a PutnamBench file directly, or sweep every unsolved problem in random order. Official answers stay hidden from the model by default.
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.
Supply documents and a goal. A resumable campaign decomposes the work, reviews proposed statements, proves the pieces, and checks separately compiled Lean modules.
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.
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.
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 ↗
Your project. Your models. Your limits.
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.
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.
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
Linux · Python 3.11 or 3.12 · A Lean project · Your model access