Experiment
Graph-based problem solving: how it works
SciLib solves a maths problem with a tree of steps rather than a single model answer. The model proposes several ideas, develops each into a solution variant, splits it into steps and checks them in Lean 4 and sympy. The whole process is recorded as a graph, and the result is one sequential proof.
How a solution proceeds
Statement
You describe the problem as text, with formulas in LaTeX. A Lean 4 formalization is optional.
Ideas
The model proposes up to eight independent ideas for a solution. Each idea is a separate branch of the graph.
Variants and steps
An idea becomes a solution variant. A variant is either solved at once or split into steps; a hard step is split further.
Solving a step
For each step the model writes the solution text, Lean 4 code and, where there is something to compute, a sympy check script.
Checking
The Lean code is compiled on a server with Mathlib, the sympy script runs in a sandbox. On an error the model receives its text and tries to repair the step.
Assembly and completeness
Step solutions are assembled into the solution of the variant. A separate branch proves completeness: that there are no other solutions.
Final solution
The verified material is turned into one sequential proof: the answer, the proof, completeness and a list of what remains unproven.
What is checked
The model's text is not taken on trust. Everything that can be checked by machine is checked by the system itself, not by the model.
- Lean 4
- The formal part of a step is compiled by Lean 4 with the Mathlib library. The “Lean ✓” mark means the code was accepted by the compiler. Failed attempts are kept as well: the page shows the code and the error text.
- sympy
- Concrete claims — roots, identities, factorizations — are checked symbolically. A refuted claim is returned to the model for repair; if that does not help, the branch is closed as failed.
- Refusals
- An answer like “this cannot be solved here” does not count as a solution: the branch is marked as a refusal.
- Degenerate formalizations
- A tautology or a theorem about a different object compiles but proves nothing about the problem. Such code is not counted as verified.
Models: Helium, Ferrum, Plutonium
You choose who solves the problem when you submit it. The method is the same in all three modes; they differ in which model plans and which one solves the steps.
Helium local model
An open model on our own hardware. Runs are free and unlimited. The slowest of the three; Lean passes on individual steps, a fully formal solution is rare.
- Plans
- Helium
- Solves the steps
- Helium
- Time per problem
- an hour or more
- Verified in Lean
- on individual steps
- Runs
- unlimited
Ferrum combined mode
The strong model plans, splits the problem into steps, assembles the solution and proves it in Lean; Helium solves the elementary steps. Much cheaper than Plutonium with a similar share of verified solutions; in time, closer to Helium.
- Plans
- Plutonium
- Solves the steps
- Helium
- Time per problem
- 40–60 minutes
- Verified in Lean
- most solutions
- Runs
- daily limit
Plutonium strong model
The strong cloud model does everything itself: planning, solving the steps, assembling the solution and proving it in Lean. The fastest and most reliable mode.
- Plans
- Plutonium
- Solves the steps
- Plutonium
- Time per problem
- 10–25 minutes
- Verified in Lean
- most solutions
- Runs
- daily limit
| Model | Problems | Final solutions | Of these, verified in Lean | Time per problem |
|---|---|---|---|---|
| Plutonium | 5 | 40 | 32 (80 %) | ≈ 16 min |
| Ferrum | 3 | 24 | 20 (83 %) | ≈ 47 min |
| Helium | 1 | 8 | 0 (0 %) | ≈ 92 min |
The sample is small: the numbers show the order of magnitude, not exact statistics. With Helium, Lean passed on 11 individual steps, but no final solution was verified as a whole.
What you get
- Final solution
- One sequential proof with rendered formulas: the answer, the proof, completeness and what remains unproven. Steps backed by verified Lean code are marked. The text is written in Russian by default.
- Solution outline
- A tree: variant → steps → step solution. Each line shows whether the step is solved, whether Lean passed and how many attempts there were.
- Solution graph
- An interactive graph of the whole run. Any node can be opened: the text, the Lean code, the check result.
- Email when it is done
- The problem is solved in the background. You can close the page: a link to the result arrives by email.
Worked examples are in the library of solved problems: 59 equations of the PolyaninBench benchmark solved by this method with the Helium model, each with its solution graph.
Limits of the method
- “A solution was found” is a structural outcome: every branch is closed and the texts are assembled. Whether the mathematics is right is for you to judge — there is no automatic judge for user problems.
- “Lean ✓” confirms the code, not that the theorem statement matches the problem.
- Helium rarely brings a solution to a complete formal check; Ferrum and Plutonium do so far more often.
- One problem per user is solved at a time; Ferrum and Plutonium runs are limited per day.
Questions and answers
What is graph-based solving?
It is a way to solve a maths problem with a tree of steps rather than a single model answer. The model proposes several ideas, each idea becomes a solution variant, a variant is split into steps, the steps are solved and checked one by one and then assembled into a single proof. The whole process is recorded as a graph, and every node of it can be opened.
How do Helium, Ferrum and Plutonium differ?
Helium is a local model on our own hardware: runs are free and unlimited, but a solution takes an hour or more and Lean passes only on individual steps. Plutonium is a strong cloud model: 10–25 minutes per problem, most solutions verified in Lean. Ferrum is the combined mode: Plutonium plans and assembles the solution, Helium solves the elementary steps.
Does the “Lean ✓” mark mean the problem is solved correctly?
No. The mark means that the formal code of a step was accepted by the Lean 4 compiler. The theorem statement is also written by the model and may not express exactly what the problem asks. Degenerate formalizations are filtered out, but whether the statement matches the problem is for a human to judge.
How long does a solution take?
From ten minutes with Plutonium to an hour or more with Helium. The problem is solved in the background: you can close the page, and an email with a link to the result arrives when it is done.
What kind of problems can I submit?
Problems with a precise mathematical statement: equations — algebraic, functional, differential, integral — and statements to be proved. The statement is written as text with formulas in LaTeX; a Lean 4 formalization is optional.
Who can see my problems and solutions?
Only you: problems are submitted in your personal space after signing in. The public library contains only PolyaninBench benchmark problems. In the Ferrum and Plutonium modes the statement is sent to a cloud model for processing.