How Turing Agent works
Verifying a research result means more than proving a theorem whose formal statement is handed to you. Papers bring their own definitions, conventions and intermediate results, and every one of them must be translated faithfully before proof search can even start. Turing Agent is built around that whole process.
Three requirements
Every formal development has to satisfy three requirements at once. Most automated provers address only the last one, starting from statements that are already formalized.

Preserve the original claim
The Lean statement must keep the domains, quantifiers, assumptions and conclusion of the natural-language claim. A statement can compile and still say something else.
Pass Lean's checks
Syntax, type and elaboration errors must be resolved through iterative debugging so Lean produces a valid proof term.
Leave no gaps
Every proof obligation is discharged — no sorry — across long developments with many dependent auxiliary results.
A two-scale architecture
Turing Agent separates theorem formalization from proof formalization. The main theorem is formalized and reviewed before proof construction begins, and stays fixed afterwards. Intermediate claims go through the same check selectively while the proof is being built. Agents are grounded in Mathlib and the domain library CSLib.

Theorem formalization (TF) agent
Searches Mathlib and CSLib for suitable definitions, introduces new ones where the libraries fall short, and writes the Lean statement. After Lean accepts it, the agent reviews whether domains, assumptions, quantifier dependencies and conclusion match the source — comparing the text against the statement, its elaborated type and the full bodies of new definitions — and revises until both checks pass.
Proof decomposition into a DAG
Guided by the informal proof, a proof formalization (PF) agent splits a goal into intermediate claims and records their dependencies in a directed acyclic graph. A split is accepted only after Lean verifies that the child statements, taken as assumptions, imply the parent. The procedure recurses; goals that can be proved directly are not split.
Parallel construction
Independent child goals are assigned to several PF agents at once. Each revises or further decomposes its claim from Lean feedback; verified branches are rechecked before the checked derivation closes the parent, continuing upward to the main theorem.
Selective semantic review
The decomposition check proves that children imply the parent, not that they match the informal argument. Reviewing every claim would be costly, so PF agents request a TF review only when a new concept's meaning is uncertain, assumptions or quantifiers are unclear, or a reformulated claim may change scope.
Experience extraction & reuse
Compressing long interaction histories loses findings. PF agents extract evidence-backed records — useful library lemmas, required side conditions, causes and fixes of failures — merge them per claim, and receive the relevant records after each context compaction.
Final verification
An independent Lean kernel rechecks the assembled proof against the fixed statement (with an axiom audit). A review agent then compares the proof with the informal argument: regrouping steps is fine; omitted essential steps, unsupported assumptions or a substituted argument are flagged.
Verification can reshape the mathematics
Working through research-level proofs revealed two behaviours beyond certifying correctness.
Exploiting mathematical freedom
Existential statements often admit many witnesses, some far easier to formalize than others. The agent picks constructions that turn case-heavy comparisons into uniform arithmetic — alternative mathematics optimized for machine reasoning.
More certified knowledge than needed
Turing Agent often verifies auxiliary results that do not end up in the final dependency structure. Rather than being discarded, they remain as reusable, machine-checked artifacts.