Graph-based problem solving: how it works · SciLib

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.

Submit a problem Library of solved problems

How a solution proceeds

  1. Statement

    You describe the problem as text, with formulas in LaTeX. A Lean 4 formalization is optional.

  2. Ideas

    The model proposes up to eight independent ideas for a solution. Each idea is a separate branch of the graph.

  3. 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.

  4. 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.

  5. 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.

  6. Assembly and completeness

    Step solutions are assembled into the solution of the variant. A separate branch proves completeness: that there are no other solutions.

  7. Final solution

    The verified material is turned into one sequential proof: the answer, the proof, completeness and a list of what remains unproven.

Solution graph diagram The problem branches into ideas, each idea yields a solution variant, a variant is split into steps checked in Lean, and the steps converge into the solution of the variant. A separate branch proves completeness. The solutions and the completeness conclusion are assembled into the final solution. Problem Idea 1 Idea 2 Idea 3 Variant 1 Variant 2 dead end Step · Lean ✓ Step · Lean ✓ Step · sympy ✓ ★ Solution 1 ★ Solution 2 Completeness Step ∎ Conclusion Final solution
This is what a solution graph looks like: the problem on the left, then ideas, variants and steps with their checks. The solutions of the variants and the completeness conclusion converge into the final solution.

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
Measurements on PolyaninBench benchmark problems, November 2026
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.