LLM Math Evaluation: The Gap Between Problem-Solving and Research
This article examines why traditional LLM benchmarks fail to capture genuine research ability, using a research-level evaluation framework built around theoretical computer science (TCS). It contrasts problem-solving with research across goal, path, verification, time scale, and the very definition of failure; explains why automated proof verification makes research-level grading feasible; and summarizes the boundaries the evaluation exposes—no frontier model could independently crack open conjectures. It closes with practical guidance for developers on choosing evaluations by capability goal, prioritizing verifiability, and designing human-machine collaboration.
Introduction: When AI Starts “Writing Papers,” How Should We Measure It?
Over the past two years, AI’s presence in mathematics has grown steadily louder. One AI vendor released hundreds of model-generated mathematical manuscripts at once, grouping them by relevance into hundreds of “result families” spanning more than a dozen directions, including number theory, theoretical computer science, geometry, and mathematical physics. The reaction was electric, and “AI has finished off mathematics” briefly trended.
Behind the noise, though, a more measured question deserves attention: Is generating a pile of text the same thing as completing a piece of mathematical research?
A recent preprint, co-authored by a Turing Award laureate and researchers from a large-model team, puts this question on the table. They built a research-level evaluation framework around theoretical computer science (TCS) and used it to test the strongest large models available today. The conclusion is sobering: when faced with open conjectures that remain unsolved to this day, none of the evaluated models could genuinely crack them on their own.
This article doesn’t dwell on the emotional verdict of “is AI capable or not.” Instead, starting from evaluation methodology, it breaks down why traditional leaderboards fail to measure research ability, and what a competent research-level evaluation should actually look like.
1. Why Benchmark Leaderboards Can’t Reflect Research Ability
Open any model leaderboard and you’ll notice the scores refresh almost every two months. MMLU, math reasoning sets, code benchmarks—there are so many boards that it’s hard to keep up. But these leaderboards share one hidden assumption: every question has a standard answer, and the process follows a fixed path.
It’s like a word problem in an exam. You know which formulas to use, in what order to solve, and what the final answer looks like. If a model gets it right, it has mastered that problem type. But this kind of evaluation essentially measures the ability to reproduce a known solution, not the ability to discover an unknown one.
To use cooking as an analogy: doing a problem is following a recipe to stir-fry a dish of sweet-and-sour pork—the steps are ready-made, the taste has a standard, and no one adds chocolate. Doing research has no recipe; no one guarantees a given path will work, and often even the person posing the question doesn’t know whether an answer exists.
This is the first key gap: the distribution of problems in an evaluation determines the ceiling of the ability it can measure. A question bank built on “standard answers” can never measure the research ability to produce new answers.
2. The Essential Difference Between Solving Problems and Doing Research
To understand why frontier models get “stumped,” we first need to clarify the fundamental difference in capability demands between problem-solving and research.
| Dimension | Problem-Solving | Research |
|---|---|---|
| Goal | Find an answer that is known to exist | Propose and verify a previously unknown conclusion |
| Path | Mature methods and established routines exist | Requires self-exploration, trial and error, and construction |
| Verification | Compare against the standard answer | Requires a complete, checkable, rigorous proof |
| Time scale | Single turn or short reasoning chain | Long cycle, multiple iterations |
| Definition of failure | Wrong answer | May have no solution at all, or the direction itself is wrong |
Theoretical computer science illustrates this difference especially well. Rather than caring about “how to fix a computer” the way a programmer might, it studies “computation” itself: How fast can we get from point A to point B at best? Is there a path that is doomed to fail? These questions revolve around the word “computation,” and almost all of them rely on mathematical proof to answer.
A model can score high on standardized question banks yet still be at a loss when it needs to “propose a brand-new proof strategy.” It’s like a test-taking specialist who isn’t necessarily a good researcher—the former is skilled at quickly matching within an existing framework, while the latter has to open up roads in uncharted territory.
3. The Real Obstacle: Grading Is Harder Than Posing Questions
Even if we could design research-level questions, a trickier problem remains: how do we grade them?
Traditional evaluations have standard answers, so you just compare. But when a model does research, it might churn out hundreds of pages of “proof” in one go. Who has the time to check it page by page manually? Worse, mathematical proofs often contain errors that aren’t easy to verify—a step that looks reasonable may hide a fatal flaw.
Interestingly, mathematics has a unique advantage here: the correctness of a proof can, to a large extent, be left to machines to check automatically. It’s a bit like Sudoku—filling it in is hard, but once it’s done, running a validation pass instantly tells you whether it’s correct. This property of “results being mechanically verifiable” makes mathematics one of the fields where AI can most easily produce “undisputed results.”
From this, we can distill several design principles for a research-level evaluation:
- Take “proposing new conclusions” rather than “reproducing old solutions” as the core objective;
- Questions must cover the full spectrum from known to open, rather than cherry-picking only those with standard answers;
- Verification should rely on automated, rigorous checking, separating “correctness of results” from “soundness of process”;
- Set a clear “unsolved” baseline for open conjectures, to prevent models from sneaking through with plausible-sounding reasoning.
The illustrative pseudocode below shows the basic skeleton of such an evaluation framework:
def evaluate_research_capability(model, problem):"""Research-level evaluation: distinguish 'reproducing known work' from 'producing new knowledge'"""# 1. The model attempts to provide a solution or proofcandidate_proof = model.solve(problem.statement)# 2. Mechanized correctness check (e.g., proof checker / formal verification)if not proof_checker.verify(candidate_proof, problem):return Result(status="FAILED", reason="Proof cannot be verified")# 3. Distinguish difficulty levelsif problem.is_open_conjecture:# Open conjecture: a genuine proof here is a breakthrough contributionreturn Result(status="BREAKTHROUGH", proof=candidate_proof)elif problem.is_known_but_hard:# Known-answer but difficult problem: check whether it can independently# reproduce a non-trivial solutionreturn Result(status="SOLVED", proof=candidate_proof)else:return Result(status="SOLVED", proof=candidate_proof)
The key point of this skeleton is treating “whether it can compute the right answer” and “whether what it computed is a genuinely open problem” as separate layers. Only the latter truly touches on “research ability.”
4. The Boundary the Evaluation Reveals: How Far Is AI from a “Theoretical Computer Scientist”?
When this research-level framework is actually put to use, the conclusion isn’t encouraging: on those open conjectures that remain unsolved to this day, none of the evaluated frontier models could crack them independently.
This result draws several clear boundaries:
The ceiling of pattern matching. Models excel at forming associations between patterns they’ve seen in training data, but genuinely open problems have no ready-made pattern to follow. A model can maneuver flexibly near “known solutions,” yet struggles to construct entirely new ideas from scratch.
The fragility of long-chain reasoning. A mathematical proof is often a rigorous chain of hundreds of steps, and an error at any single link can bring the whole thing down. Error accumulation in long-chain reasoning is one of the most stubborn obstacles today.
The absence of problem-posing ability. Research requires not only “solving the questions posed” but also “posing questions worth solving.” Finding good questions and judging whether a question is valuable—this kind of metacognitive ability remains firmly in the hands of human researchers.
In other words, current frontier models are closer to a highly efficient “problem-solving scholar” than to a “research scholar” who can independently open up new directions. They can be a powerful co-pilot for researchers, but not yet a captain who can steer alone.
5. Practical Implications for Developers
For developers and enterprises building AI applications and evaluating model choices, this evaluation offers a few actionable takeaways:
Choose evaluations by capability goal, not by blind faith in a single leaderboard. If your scenario is “reproducing known solutions” (such as standard Q&A or code completion), traditional leaderboards are sufficient; if your scenario involves “open-ended reasoning and generation” (such as research assistance or complex decision-making), you must introduce research-level evaluations with automated verification.
Bring “verifiability” into technology selection. Prefer scenarios where outputs can be mechanically verified to carry a model’s higher-order capabilities, just as mathematical proofs can be handed to machines to check. On platforms and toolchains such as Baidu AI Cloud, embedding model capabilities in a “generate-verify-feedback” closed loop is often more robust than simply chasing the accuracy of a single generation.
Design human-machine collaboration for “open problems.” Acknowledge the model’s limitations on open conjectures, and position its role as a “hypothesis generator” and “bearer of repetitive computation,” while humans handle problem definition and direction-setting.
Focus on the stability of long-chain reasoning. In tasks requiring multi-step rigorous derivation, decomposing the task, introducing intermediate checkpoints, and tracking the failure points of the reasoning chain with logging and monitoring/alerting services can effectively mitigate error accumulation.
Conclusion
Progress in AI on mathematics and theoretical computer science is real, but there’s a clear gap—drawn by evaluation methodology—between “being able to generate manuscripts” and “being able to complete research.” The value of a research-level evaluation lies precisely in its refusal to be dazzled by pretty scores, pointing instead to one essential question: Is the model reproducing the past, or creating new knowledge?
The current answer leans conservative. But that’s actually a good thing—a clear boundary means a clear next step. For developers, understanding this boundary is what lets you use models where they truly excel and design human-machine collaboration that is both efficient and reliable.
