Every few months, a tech headline claims an artificial intelligence model just cracked a decades-old mathematical or computer science conjecture, and every few months, the actual mathematicians have to spend weeks cleaning up the mess.
The latest breathless narrative asks whether AI just solved a 30-year-old computer science puzzle while "experts are checking." That phrasing alone reveals the entire rot at the center of modern tech journalism. In mathematics and theoretical computer science, a proof is not a software beta that gets shipped first and debugged in production. Either a proof is verified, or it does not exist. Calling an unverified, machine-generated output a "solution" is like calling a lottery ticket a retirement plan before the numbers are drawn.
The lazy consensus wants you to believe we are witnessing the birth of automated genius—machines peering into the platonic heavens and pulling down truths that eluded human minds for generations. The reality is far less romantic and infinitely more useful. When you strip away the PR spin from AI labs, these breakthroughs are rarely instances of a machine "thinking" its way through a theoretical wall. They are brute-force search optimizations wrapped in a neural network, operating inside problem spaces that humans already painstakingly carved out, formalized, and translated into code.
If you want to understand where automated theorem proving and algorithmic discovery actually stand—and stop falling for press releases disguised as journalism—you need to look at how these systems work under the hood.
The Verification Bottleneck Nobody Wants to Fund
Walk into any enterprise AI deployment or academic lab right now, and you will see the exact same pathology. Millions of dollars get thrown at compute clusters to generate candidate solutions, while almost nothing gets spent on the infrastructure required to prove those candidates are not sophisticated hallucinations.
I have watched engineering teams burn through seven-figure cloud budgets running evolutionary search algorithms and large language models to optimize compiler passes and scheduling heuristics, only to discover months later that the "breakthrough" algorithms silently broke edge-case invariants in production. Generation is cheap. Verification is brutally expensive.
When a headline says "experts are checking" an AI's solution to a classic computer science problem—whether it involves matrix multiplication bounds, the cap set problem, bin packing heuristics, or circuit complexity—it glosses over the hardest part of the discipline. Formal verification is the entire ballgame.
Consider how actual progress happens in this space:
- The Human Framing: A human researcher spends months or years translating an abstract mathematical conjecture into a rigid, computable search space or a formal proof assistant like Lean, Coq, or Isabelle.
- The Stochastic Search: An AI system—often a combination of a large language model and a Monte Carlo tree search or evolutionary loop—generates millions of candidate expressions, code snippets, or proof tactics.
- The Deterministic Filter: A traditional, non-AI symbolic verifier or compiler checks whether the candidate violates any axioms or constraints.
Notice what is doing the actual proving in step three. It is not the neural network. It is the deterministic, rule-based formal verifier built by computer scientists decades ago. The AI is simply a high-speed, probabilistic guesser throwing darts at a board at a million miles per hour, while a human-built referee blows a whistle every time a dart hits the bullseye.
Giving the neural network credit for "solving" the puzzle while treating the formal verifier as an afterthought is like praising a blindfolded pitcher for throwing a strike without mentioning the automated radar gun and the catcher doing all the work to keep the ball in the park.
Pattern Matching Is Not Conceptual Understanding
When Google DeepMind announced FunSearch—a system that paired a language model with an evaluator to find new solutions to the cap set problem and better heuristics for online bin packing—the media coverage immediately spiraled into existential territory. Pundits wrote as if silicon had finally conquered pure reason.
Let us look at what actually happened, because the nuance matters.
In the cap set problem, mathematicians want to know the largest possible subset of points in a high-dimensional grid where no three points form a straight line. It is a foundational problem in extremal combinatorics, closely tied to fast matrix multiplication. FunSearch did not sit down, read Terence Tao’s papers on polynomial methods, develop a new algebraic intuition, and write a conceptual proof.
Instead, researchers asked an LLM to generate short Python programs that scored potential point configurations. The evaluator ran those programs, measured the size of the resulting cap sets, kept the highest-scoring functions, and fed them back into the prompt to mutate them further.
It was automated program synthesis guided by evolutionary pressure. It found larger cap sets in specific dimensions than humans had previously constructed. That is a genuine, impressive engineering achievement.
It is also completely different from solving a conjecture.
Finding a counterexample or constructing a larger finite object is an existence proof by exhaustion. You exhibit the object, anyone can check its properties, and the case for that specific dimension is closed. That tells you almost nothing about the asymptotic behavior as dimensions approach infinity. It does not explain why the structure works. In mathematics, knowing that something is true without knowing why is a dead end. Grothendieck did not transform algebraic geometry by finding slightly bigger numbers in a grid; he transformed it by building conceptual frameworks that made previously impossible problems trivial.
Neural networks do not build conceptual frameworks. They interpolate across statistical distributions of human-written tokens. When they stumble onto a novel algorithm—like AlphaTensor finding a faster way to multiply 4x4 matrices over a finite field—they are navigating a discrete search space that humans had to carefully restrict so the search wouldn't explode combinatorially.
Even then, look at what happened after AlphaTensor's splashy Nature cover. Within weeks, human mathematicians looked at the tensor decompositions the AI found, understood the underlying symmetry, and immediately generalized them by hand to beat the AI's own records. The machine found a pebble; the humans mapped the mountain.
Why Asking "Can AI Solve Hard Math?" Is the Wrong Question
Search trends around this topic are flooded with the exact same anxious, binary questions: Can AI replace mathematicians? Will AI solve P vs NP? How did AI solve a 30-year-old puzzle?
Every single one of these questions rests on a broken premise. They treat mathematics and theoretical computer science as trivia contests where the goal is simply to spit out the final answer at the back of the textbook.
If you ask a working complexity theorist whether an AI will solve P vs NP anytime soon, they will laugh—not out of arrogance, but because we do not even have the mathematical vocabulary yet to bypass known barriers like relativization, natural proofs, and algebrization. As Scott Aaronson and Avi Wigderson have spent careers demonstrating, resolving foundational complexity questions requires inventing entirely new mathematical universes, not just searching existing ones faster.
The real question isn't whether AI can replace human theorists. The real question is: Which class of problems in computer science is actually a disguised search problem, and which requires genuine conceptual abstraction?
If you conflate the two, you will waste years and millions of dollars applying the wrong tool to the wrong bottleneck.
| Problem Type | What It Actually Requires | AI's Real Utility | Where the Hype Lies |
|---|---|---|---|
| Asymptotic Conjectures (e.g., P vs NP, Riemann Hypothesis) | New mathematical definitions, structural abstractions, bridging disparate fields | Near zero for end-to-end proofs; minor assistance in checking small edge cases | Assuming scaling compute will magically birth new conceptual mathematics |
| Combinatorial Constructions (e.g., Cap Set, Ramsey numbers) | Finding specific finite structures that satisfy rigid constraints | High, when paired with deterministic evaluators and evolutionary loops | Calling a finite dimensional construction a "solution" to the general theory |
| Algorithmic Heuristics (e.g., Bin packing, matrix multiplication) | Discovering lower-rank decompositions or tighter sorting/routing rules | Very high; excels at exploring non-intuitive code mutations | Ignoring that human mathematicians frequently generalize past the AI's output in weeks |
| Formal Proof Verification (e.g., Lean formalization) | Translating informal human proofs into machine-checkable logic | Moderate to high as an autocomplete engine for routine proof tactics | Claiming the AI "proved" a theorem when a human already wrote the blueprint |
The Quiet Cost of Premature Victory Laps
There is a real cost to publishing articles claiming AI solved a 30-year-old puzzle before the peer-review ink is dry.
First, it corrupts scientific incentives. When labs get rewarded with front-page coverage for unverified claims or narrow benchmark wins, the pressure to release premature results becomes overwhelming. We already saw this play out in physics with LK-99 and in biology with countless overhyped protein-folding claims that failed wet-lab validation. Computer science is supposed to be the one discipline where proof is absolute. Turning it into a spectator sport of "experts are checking" lowers the bar to the floor.
Second, it blinds technical leaders to how they should actually use these tools. If a CTO reads that AI is autonomously solving decades-old theoretical puzzles, they start believing they can point an off-the-shelf foundation model at their legacy codebase, their database query optimizer, or their supply-chain routing engine and expect miracles.
They try it. The model hallucinates subtle logic bugs that pass superficial unit tests. Six months later, they quietly rip it out.
I am not arguing that AI is useless in theoretical computer science. Dismissing automated theorem proving and neural-guided search as mere toys is just as wrongheaded as claiming they have achieved superintelligence. Terence Tao himself has been vocal about how Lean and AI-assisted proof tools are changing his workflow—not by replacing his intuition, but by allowing him to collaborate with larger teams and verify complex proof steps without every contributor needing to master the entire proof architecture.
That is a massive shift. When formal verification becomes cheap enough to use routinely, mathematicians can take bigger risks, delegate lemmas to automated solvers, and build towering proofs that no single human brain could hold in working memory at once.
The catch—and the downside even insiders rarely admit—is that formalization itself introduces a massive translation tax. Turning a crisp, two-page human insight into ten thousand lines of rigid Lean code takes grueling manual labor. Right now, AI struggles mightily with that translation step because natural-language math relies on unstated context, intuition, and deliberate ambiguity that formal compilers reject instantly. Until models can bridge that gap reliably, human bottlenecks remain firmly in place.
How to Read the Next "AI Solved Math" Headline
Stop letting press releases dictate your understanding of computational progress. The next time a viral story claims an algorithm cracked an ancient puzzle, run it through three brutal filters before sharing it:
- Check the verifier, not the generator. Ask what deterministic system confirmed the output. If the answer is "human experts are still checking," close the tab. Come back in six months when the formal proof compiles in Lean or passes peer review in a real journal.
- Separate finite bounds from general proofs. Did the system find a better constant in dimension 8, or did it prove a theorem that holds for all $n$? Finding a needle in a haystack is engineering; proving no needles exist in an infinite field is mathematics.
- Look for the human scaffolding. Read the methods section to see how much domain knowledge the researchers hardcoded into the search space and the reward function. Almost every time, you will find that human ingenuity did 90 percent of the heavy lifting before the GPUs even spun up.
Artificial intelligence is an extraordinary flashlight for exploring dark, massive search spaces that human brains are too slow to traverse manually. It is a terrible substitute for the human mind deciding where to point the beam. Until a machine can formulate a question worth asking on its own, the puzzles aren't being solved by AI—they are being solved by computer scientists using a louder, faster hammer.