Alpha isn't what you think. It never is.
722 manuscripts. 372 problems. Roughly two candidate write-ups per problem, handed to working mathematicians to comb through by hand, one by one, hunting for the ones that actually hold. That is the entire factual skeleton of the story that got laundered this week into "AI is now doing original mathematics." The number nobody printed — because the source didn't print it — is the one that decides everything: the compile rate. How many of those 722 manuscripts end in a Lean kernel that says, coldly and without opinion, "proof accepted," versus how many end in a natural-language shrug dressed up as a theorem.
I've spent the last month staring at a different number. Cumulative value drained from cross-chain bridges, now north of $2.5 billion. I watch that figure the way a surgeon watches a heart monitor, because I run $2 million of live liquidity across Arbitrum, Optimism, and Base, and every bridge in that stack is a promise I am financially forced to keep believing. When I read that OpenAI had a model producing 722 mathematical manuscripts, my first thought wasn't "AGI." It was: if a machine can write a Lean proof that a kernel verifies, then it can write a Lean proof that a $400 million bridge contract won't drain. That is the trade. Not the math. The security.
Let me be surgical about what I didn't see in the coverage, because the gap between the headline and the mechanism is where your money lives.
The Mechanism Nobody Named
Here is what the story actually describes, stripped of the excitement: an unreleased reasoning model from OpenAI was pointed at a corpus of math problems. It generated candidate solutions. Those solutions were then subjected to formal verification — the article's own framing leans on Lean, the dominant proof assistant in academic mathematics, whose Mathlib library holds hundreds of thousands of already-formalized theorems. A batch of mathematicians was invited to comb through the output.
That is a neuro-symbolic pipeline: a large language model doing the long-chain reasoning, and a formal verifier acting as the judge that cannot be sweet-talked. The LLM proposes; Lean disposes. This is not a chatbot claiming it solved a problem in prose. This is a system where the output has to survive a compiler.
And that distinction is the whole ballgame, because it changes what "solved" even means.
When a language model writes "therefore the conjecture holds" in fluent English, you have a vibe. When it emits a Lean term that type-checks against a kernel, you have a fact — or at least a fact conditional on your theorem statement being the right theorem. Formal verification is the single most trustworthy signal in the entire AI-mathematics space precisely because it removes the model's ability to lie. The kernel does not care about confidence. It does not care about tone. It compiles or it doesn't.
Formal verification is the only anti-hallucination technology that actually scales, because it doesn't ask the model to be honest — it makes honesty structural.
That is the part of this story that crypto should have been screaming about, and instead the coverage went to "AI does math." Which is like reporting that a new fighter jet can fly, when the actual news is that it can land on a moving carrier at night.
Context: Why Lean Is the Signal, Not the Noise
To understand why 722 manuscripts matters, you have to understand what Lean is and why the math community treats it as ground truth.
Lean is a proof assistant — a programming language for mathematics. You state a theorem, you write a proof, and a small trusted kernel checks every step against the rules of dependent type theory. If the proof compiles, the theorem is true, full stop. Mathlib, the community library built on top of Lean, has spent years formalizing a vast swath of undergraduate and graduate mathematics. It is, functionally, a machine-checkable encyclopedia.
Now here's why this matters more than the IMO medals that get trotted out every year. Google DeepMind's AlphaProof and AlphaGeometry reached silver-medal performance at the 2024 International Mathematical Olympiad — four of six problems — using Lean for the formalization step. That set the benchmark. Any lab that wants to claim leadership in "verifiable reasoning" has to be measured against it, whether it likes it or not.
The OpenAI event is, structurally, an attempt to enter that arena. Not with a benchmark scorecard, but with a narrative: unreleased model, large-scale manuscript generation, independent mathematician review. That's a credibility play, not a capability disclosure. It's the same pattern OpenAI used in the o1 preview era — show experts first, build the myth, publish the numbers later.
But here is the trap in the wording, and I want you to sit with it. The article says manuscripts. Not proofs. Not formalizations. Not Lean terms. If the outputs were complete, kernel-checked Lean files, the natural word is "proofs." "Manuscripts" reads like natural-language mathematical narrative — argument sketches, exposition, partial reasoning. That is a materially weaker artifact than a compiling proof, and it hints that the formal coverage might be partial: some steps checked, others asserted in prose.
So the honest read is this. The technical direction — LLM long-chain reasoning fused with a formal verifier, trained most likely via reinforcement learning with verifiable rewards (RLVR), where Lean compilation success is the reward signal — is real and it is where the frontier is going. The scale — 722 manuscripts across 372 problems, roughly 1.94 attempts per problem — smells exactly like best-of-n sampling with rejection filtering. You generate two candidates, you keep the ones that survive. That's engineering, not magic. And the "unreleased plus expert review" framing is a proof-of-concept posture, not a product launch.
What the coverage did not give you: the problem difficulty (Olympiad? Undergraduate? Open frontier conjectures?), the formalization coverage ratio, whether the model autonomously wrote and debugged its own Lean code or merely produced ideas for humans to formalize, and — the number that matters most — the end-to-end compile pass rate.
Every one of those omissions is load-bearing. Because the pass rate is the difference between "AI is doing mathematics" and "AI is generating plausible-looking mathematical text that humans then have to filter." Those are not the same achievement. They are not even close.
The Crypto Connection: Formal Verification Was Always the Missing Layer
Now let me make the jump that the crypto-native reader already felt in their gut, and that the general coverage completely missed.
Formal verification is not an academic curiosity. It is the load-bearing wall of smart contract security, and it has been failing under its own weight for years — not because it's wrong, but because it's expensive. Writing a formal specification of a DeFi protocol and proving the implementation matches it is brutal, slow, expert-labor work. So the industry mostly doesn't. It ships, it audits (shallowly, under deadline), and it prays.
Then it gets drained.
The bridge hacks are the graveyard of that prayer. Cumulative losses past $2.5 billion, and the pattern repeats with almost boring regularity: a signature verification flaw, a message-passing trust assumption, a reentrancy path nobody modeled, an upgrade mechanism with a hole you could drive a validator set through. Every single one of those is a formal specification gap. The code did exactly what it was written to do. It just wasn't written to do the right thing, and nobody had the budget or the formalism to prove the difference.
So connect the dots. If OpenAI — or DeepMind, or anyone — can build a model that turns natural-language intent into Lean-verified proofs at scale, the cost curve of formal verification collapses. And the first place that collapse pays off is not pure mathematics. It's code that moves money.
A machine that can prove a theorem can prove a contract invariant. Same skill. Same verifier. Different victim profile.
I know this because I've been on the wrong side of it. In early 2025 I stood up an autonomous AI trading agent on Ethereum L2s — $100,000 of test capital, permission to fire up to 50 trades off social-volume spikes. It made money and lost money in the same week, and the thing that gutted it wasn't bad sentiment modeling. It was a governance attack vector I never formalized, never specified, never proved absent. The bot executed faithfully into a trap the contract's own design had left open. I lost $30,000 to a class of bug that a formal invariant — "this function can never increase an attacker's claim beyond X" — would have flagged before I deployed a single dollar.
That's the lesson the math story should have taught, and it's the lesson the industry keeps refusing to learn: the failures that kill capital are almost never logic errors. They are specification errors. The code does what you told it. You just told it the wrong thing, and you never had the tooling to catch the gap.
Core: What a Verified-Prover Pipeline Would Actually Change
Let me build the model of how this plays out, because the second-order effects are where the alpha lives.
Layer 1 — Audit economics invert
Today, a formal verification engagement for a serious protocol runs into the high six figures and takes months. The bottleneck is human: senior formal-methods engineers are scarce, and their time is the product. If an LLM-plus-Lean pipeline can generate candidate proofs and invariants, the human role shifts from writing proofs to reviewing and steering them — exactly the role the 722 mathematicians are playing right now. That is a 10x to 100x throughput change, and throughput changes are what reprice entire service industries.
Layer 2 — The audit becomes continuous, not a gate
The reason audits fail is that they're snapshots. You verify the contract on Tuesday; on Wednesday someone pushes an upgrade and the proof is stale. Continuous formal verification — where every commit is re-checked against a machine-readable spec — becomes feasible only when the marginal cost of a proof approaches zero. That is precisely what a strong reasoning model drives toward.
Layer 3 — The verifier becomes the product
Here's the part that should make every bridge operator nervous and every security firm excited. The value doesn't live in the model that writes proofs. It lives in the trusted kernel that checks them. Lean's kernel is small and battle-tested; that's why the math community trusts it. Any crypto-native formal verification stack inherits that trust only if it inherits the same discipline — small kernel, public rules, adversarial review. The moment a company wraps verification in proprietary black-box tooling, it has rebuilt the exact oracle-trust problem that keeps getting DeFi exploited.
And that's where I plant my flag on the contrarian side, because the enthusiasm is about to get ahead of the evidence.
Contrarian: 722 Manuscripts Is Not 722 Proofs, and the Difference Is Your Money
Let me be cold about this, because the warm version is a trap.
The coverage wants you to hear "722." The number you should hear is "unknown." Here's why that gap is dangerous, and here's why it should scare you more than any exploit headline.
First, the manuscript-versus-proof problem. If the outputs were complete Lean proofs, the pass rate would be the headline. It isn't. "Combing through" is the language of filtering, and filtering implies a lot gets filtered out. The honest base case is that the fully-verified fraction is well below 100%, and possibly far below. When the number arrives — and it will, via some independent reviewer — expect it to be dramatically lower than the narrative implies. That's not failure. That's how best-of-n sampling works: you generate a lot, you keep a little, and the little you keep is still valuable. But you cannot price the capability off the generation count. You price it off the keep count.
Second, the survivorship trap. The single most dangerous thing OpenAI could do — and the thing every lab is tempted to do — is disclose only the wins. If 30 of 372 problems produced clean, kernel-checked proofs and the other 342 produced noise, the press release says "we proved 30 hard theorems." That's technically true and substantively misleading, because it hides the denominator. I've watched this movie in DeFi. Every yield protocol shows you the APY and hides the drawdown. Every bridge shows you the TVL and hides the trust assumptions. The market doesn't reward what you show. It punishes what you hide. When the hidden thing is a pass rate, the market will eventually find it, and when it does, the repricing is violent.
Third — and this is the one that actually keeps me up at night — formal verification is not legal safety, and it is not economic safety. This is the mistake crypto makes over and over. A contract can be formally proven to do exactly what its spec says and still be an economic weapon. You can prove the math of an oracle-free invariant and still get liquidated by a feed that lags three blocks. You can prove a bridge's message-passing is sound and still get drained because the validator set is five keys on one cloud provider. Lean verifies logic. It does not verify incentives. It does not verify oracle latency. It does not verify that the team behind the upgrade multisig is honest.
Formal verification closes the logic gap and leaves every other gap wide open — and the industry will confuse the two because it desperately wants a silver bullet.
So when the headlines scream that AI is about to make smart contracts "provably safe," my answer is the same one I give when someone shows me a 400% APY with a clean audit: show me the spec, show me the kernel, and show me who controls the upgrade key. Because the proof only covers the world you wrote down. The attacker lives in the world you didn't.
I've paid for this lesson in real P&L. I don't need a whitepaper to teach it to me again.
The Oracle Problem Nobody Solved
Let me detour into the thing that formal verification structurally cannot fix, because it's the same failure mode showing up one layer up.
A verified smart contract is a closed system. It assumes its inputs are what they claim to be. But DeFi's inputs are oracles — price feeds, cross-chain messages, external state — and oracles are where trust gets smuggled back in through the basement window. Chainlink "solving decentralization" by running a set of permissioned nodes is the same joke in a different costume: you moved the trust from one operator to seven, and you called it trustless because the number got bigger.
Here's the kicker, and it's the reason the OpenAI story connects to my world more than people realize. A formal proof of a protocol's internal invariants is only as strong as the oracle assumptions baked into the spec. If your spec says "assume the price feed is correct," your proof says nothing about the scenario where the feed is manipulated. And price feeds get manipulated constantly — flash loans, thin liquidity, latency arbitrage. I front-ran this exact dynamic in 2020, back when I was a sophomore ignoring lectures to run a Python script that monitored gas and executed 400+ micro-trades a day, farming impermanent-loss arbitrage between the SUSHI and UNI launches. I made $12,000 that summer and lost 15% of it to a rug pull, and the lesson was carved into me: code is law, and speed is alpha, and the oracle is the soft spot both of them bleed through.
So when I hear "AI will formally verify DeFi," my response is: great, verify the contract. Now verify the oracle. Now verify the governance. Now verify the economic assumptions about who shows up when the incentive flips. Formal methods give you one closed box. DeFi is a room full of open ones.
The Competition Frame: This Is a Repricing of "Verifiable Reasoning"
The strategic read here is cleaner than the technical one.
DeepMind owns the formal-math high ground right now. AlphaProof on Lean, silver at IMO 2024. That's the benchmark every lab measures against. OpenAI entering this space with a narrative-first play — unreleased model, mass generation, independent review — is a direct bid for that high ground. The competitive axis is shifting from "who has the best chatbot" to "who has the most verifiable reasoning," and that shift is structural. Chat benchmarks are saturated and easy to game. Compile rates are not. A kernel either accepts your proof or it doesn't, and there's no prompt-engineering your way around a type error.
This matters for crypto because verifiable reasoning is the exact capability the security layer needs. The labs that win the formal-math race are the labs that will sell the audit-automation stack. And the labs that lose it will sell you "AI-assisted security review" that is really just a model confidently telling you a vulnerable contract looks fine.
The winner of the verifiable-reasoning race inherits the smart-contract security market by default, whether or not they ever intend to.
I'd watch three signals to know who's actually winning, versus who's winning the press cycle. One: independent, third-party compile rates, not self-reported ones. Two: whether the formalization is end-to-end autonomous or human-assisted — the difference is the difference between a tool and a toy. Three: whether any of this touches industrial-scale verification — real contracts, real chip designs, real cryptographic proofs — rather than curated competition problems. Competition problems are the demo. Industrial verification is the product.
The Infrastructure Bill Nobody Wants to Pay
One more layer, because the cost structure tells you the motivation.
Long-chain reasoning models are expensive to run. A single hard problem can burn tens of thousands of tokens in a chain of thought. Multiply that by 722 manuscripts and multiple attempts per problem and you're looking at a serious inference bill. On the training side, RLVR — reinforcement learning with verifiable rewards — is a rollout-hungry paradigm: you generate enormous numbers of candidate solutions, run each through the verifier, and update on the signal. That's training FLOPs on a scale that dwarfs plain supervised fine-tuning. Add the Lean checker itself, which is CPU-intensive proof-checking running alongside GPU inference, and you have a system that costs real money per verified theorem.
So why do it? Because OpenAI is treating mathematical reasoning as a strategic capability investment, not a near-term revenue line. That's the tell. You don't spend this much compute on an unreleased model for the fun of it. You spend it to establish the frontier, to anchor pricing power for the next generation, and to build the credibility that lets you sell "verifiable reasoning" into every high-trust industry: aerospace, semiconductor EDA, financial risk, and — yes — crypto security.
The flip side is dependency. This whole pipeline runs on top-tier GPUs, which means it runs on a constrained supply chain subject to export controls and fabrication limits. The capability is bottlenecked by silicon. That's a risk the math coverage never mentioned, and it's the same risk that throttles every ambitious AI-in-crypto roadmap.
What I'm Actually Doing With This
Let me translate analysis into positions, because that's the only thing that compounds.
I don't trade AI narratives. I trade the second-order effects that AI narratives create in markets I actually understand. So here's how I'm positioned and how I'm watching this.
On security tooling. The moment formal verification gets cheap, the security audit market restructures. Firms that are pure human-labor shops get repriced down. Firms that own a verification kernel or a spec language get repriced up. I'm watching the tooling layer — not the model layer — because the model layer is a race to the bottom on price and the tooling layer is where the moat sits.
On the bridge problem. If formal verification of bridge invariants becomes feasible at scale, the risk premium on cross-chain yield compresses. That's a direct hit to my own book: I'm currently running $2 million across Arbitrum, Optimism, and Base, manually rebalancing daily against real-time gas costs and TVL shifts, and a meaningful chunk of the yield I'm capturing is compensation for bridge risk. If that risk gets verified down, spreads tighten and my edge shrinks. I'm not rooting for the technology out of altruism. I'm modeling it because it will eat into a spread I currently own.
On the survivorship filter. When the compile rate drops — and it will, because it always does — expect a sentiment shock in the AI-in-crypto narrative. That shock will be a buying opportunity in the tooling and a disaster in the hype. I want to be positioned on the right side of that split before the number prints, not after.
I don't chase the headline. I position for the footnote. And the footnote here is the pass rate.
The Takeaway
Here's the forward-looking read, and it's not a summary — it's a watchlist.
Over the next three to eighteen months, the number that matters is not "how many manuscripts did the model generate." It's "how many of them compiled, verified by someone who doesn't work for the lab that made them." When that number surfaces — and it will, because independent mathematicians don't stay quiet and competitors don't let them — the entire AI-in-security narrative gets repriced against it. High pass rate: formal verification becomes a real, deployable layer, and the audit market inverts. Low pass rate: "AI generates mathematical-sounding text that humans filter" becomes the honest description, and the silver-bullet story dies the death it deserves.
Either way, the crypto industry's real lesson is the one it keeps avoiding. The bugs that drain your capital are not in the code you verified. They're in the spec you never wrote, the oracle you never questioned, and the key you never audited.
So watch the compile rate. Watch who controls the verifier. Watch whether the proof covers the oracle or just pretends the oracle is honest. And watch the upgrade key — because that key doesn't care how beautiful the proof is.
You don't get to call a contract "provably safe" until you've proven the whole world it lives in. Nobody has done that yet. Not OpenAI. Not DeepMind. Not anyone.
The question isn't whether AI can prove a theorem. It's whether you'll still be holding the bridge when someone proves the theorem you needed — and the money's already gone.
