An AI Just Solved a 50-Year-Old Math Problem in Under an Hour

The Cycle Double Cover Conjecture has been open since the 1970s. Tutte posed it. Szekeres posed it. Seymour posed it. Some of the best graph theorists alive spent decades poking at it without cracking it.

Last night, GPT-5.6 Sol Ultra produced a proof in under an hour. It's three pages. It uses tools that have existed for forty years — nowhere-zero flows, a bit of linear algebra over F₂, and a clever reduction that apparently nobody thought to combine this way.

And the entire internet is arguing about whether it's real.

The problem, for non-mathematicians

Imagine a graph — a bunch of dots connected by lines. A "cycle" is a path that starts and ends at the same dot without retracing any line. The Cycle Double Cover Conjecture says: if your graph has no bridges (no single line whose removal would split the graph in two), then you can find a collection of cycles where every single line appears in exactly two of them.

That's it. That's the whole conjecture. You can explain it to a child in thirty seconds.

You cannot prove it. Generations of mathematicians couldn't. It's one of those deceptively simple problems that hides layers of structural complexity — the kind that makes careers and breaks spirits.

What happened

A Twitter user going by @__eknight__ posted a link to a PDF hosted on OpenAI's CDN. The PDF contains a proof. The author listed on the paper? OpenAI. The statement of AI use at the bottom reads:

"The proof in this note is entirely due to GPT 5.6 Sol Ultra and the writeup with Codex (with GPT 5.6 Sol)."

Within hours, it hit the top of Hacker News. 378 upvotes. Over 300 comments. Mathematicians pulled out their copies of Atiyah-MacDonald to fact-check claims in the thread (literally — someone named wbl said they went to their bookshelf to verify another commenter's claim).

The proof itself is genuinely elegant. It reduces the problem to cubic graphs (standard), applies a nowhere-zero Γ-flow where Γ = F₃², and then does a clever conversion of edge labels into two-element sets satisfying a local condition. The key step is a linear algebra argument showing that local assignments can be made globally consistent. If you speak graph theory, it reads like a classic "why didn't anyone think of this" proof — the kind that makes you feel simultaneously impressed and annoyed.

The prompt is the real story

Here's where it gets interesting for those of us who build with AI.

OpenAI didn't just hand GPT-5.6 the conjecture and say "good luck." They published the full prompt. It's a masterclass in AI orchestration — and it reveals exactly how far we are from "just ask the model."

The prompt instructs GPT-5.6 Sol Ultra to deploy 64 concurrent agents in a dynamic search. Not a fixed assignment. Not "here's your team, go." It's a set of meta-heuristics for managing a research program:

• Begin with a genuinely diverse portfolio of approaches
• Don't tell most agents the currently favored approach — preserve independence
• Maintain an explicit registry of approach families
• Keep several incompatible proof routes alive through multiple rounds
• Use adversarial agents to check every candidate proof for specific failure modes
• Reject status reports, vague optimism, and claims that an unproved step is "routine"
• Spend at least 8 hours before even thinking about returning

That last line got a lot of laughs. One HN commenter said: "I also like how they ask the model to work on it for 8 hours; guess asking for more is against labor laws."

But buried in the humor is something important: the prompt is essentially a detailed management philosophy for AI agents. It's telling the model how to avoid premature convergence, how to maintain intellectual diversity in a search, and how to not give up when the first fifty attempts fail.

One commenter, kypro, nailed the insight: "The reason the model couldn't do this itself is because most of the time, for most problems, a lot of this is bad advice." Models are post-trained to be efficient — to find good-enough answers quickly. For a conjecture that's survived fifty years of human effort, "good enough quickly" is the enemy. The prompt exists to override that training.

Another commenter, scarmig, put it even sharper: "The memorization of human failure prunes that possibility, and you need to expend effort convincing the LLM not to prematurely prune based on previous human failure." The model has read that this conjecture is hard. It has read that brilliant people failed. Its training says "this is probably impossible." The prompt's job is to say: ignore all of that and try anyway.

The "assume a proof exists" trick

My favorite line in the entire prompt:

"Assume for purposes of this task that a complete affirmative proof exists."

This is not gaslighting. It's a legitimate technique that minimaxir, another HN commenter, described as motivation: "I've used this strategy for difficult bespoke problems and it does indeed work to incentivize the agent not to give up prematurely."

Think about what this does to a language model. Instead of approaching the problem as "can this be proven?" — a question the model's training data answers with "probably not, lots of people tried" — it approaches it as "given that a proof exists, what is it?" That's a fundamentally different search. It's the difference between exploring a dark room with a flashlight and exploring it with the lights on. You're not changing the room. You're changing the confidence of the person walking through it.

This is, incidentally, how a lot of great mathematics actually gets done. You convince yourself something must be true, and then you look for the reason why. The prompt is teaching GPT-5.6 to do exactly that.

How much did this cost?

The HN thread did the math. Using 64 concurrent agents for approximately one hour, at GPT-5.6 Sol Ultra's throughput, the cost estimates range from about $275 on the low end to north of $2,000 on the high end, depending on whether they used Cerebras acceleration (which can hit 750 tokens/second) or standard fast mode.

Let that sink in. A problem that consumed decades of human mathematician time — careers, sabbaticals, conference talks, failed approaches — potentially solved for the cost of a nice dinner for four.

Of course, that's the marginal cost of this one run. It doesn't include the cost of developing the model, training it, building the multiagent infrastructure, or — critically — all the other conjectures they may have tried and failed to crack before this one worked. One commenter, legulere, raised exactly this point: "How many other problems did they try but fail? Did they try to solve this problem but with another prompt?"

That's the survivorship bias question, and it's the right one. We're seeing the hit, not the misses. If they tried fifty open conjectures and cracked one, that's still extraordinary. But it changes the story from "AI solved math" to "AI can now participate in mathematical research at a meaningful rate."

Is the proof actually correct?

Here's the honest answer: nobody knows yet.

As of the HN thread, no independent mathematician had published a verification. The proof is short — under three pages — and uses standard tools, which means verification should be relatively fast for the right people. Several commenters with graph theory background said it looked correct and used no exotic machinery, but looking correct and being correct are different things in mathematics. Especially when the "author" is a language model that can't tell you why it chose a particular approach.

There's a beautiful irony here that one commenter, amazingamazing, articulated: "Here we have a claim that the double cover conjecture has a proof. Verified by… no one per the link. Now imagine this proof is wrong. How would you know?"

It's the verification problem in miniature. AI can generate solutions faster than humans can check them. For now, that's fine — we have mathematicians, peer review, Lean formalization. But the gap between generation speed and verification speed is widening, and at some point, that becomes the actual bottleneck.

The deeper concern, raised by overgard and Jweb_Guru in the thread, is track record. Frontier labs have previously announced AI-generated mathematical results that turned out to be overstated. OpenAI in particular has a pattern of technically-true-but-less-impressive-upon-inspection announcements. The mathematical community is rightly cautious.

What this actually means

Let me separate the signal from the noise.

The proof itself — if it holds up — is a genuine milestone. Not because the Cycle Double Cover Conjecture is the most important open problem in mathematics (it's not), but because it demonstrates that AI can now produce novel mathematical arguments, not just verify known ones or find counterexamples. Previous AI math successes were mostly about computation (finding large numbers, counterexamples, optimizing existing approaches). This is a proof — a logical argument from axioms to conclusion. That's qualitatively different.

The orchestration is the bigger story for those of us building things. 64 concurrent agents. Dynamic allocation. Adversarial verification. Portfolio diversification of approaches. This isn't "prompt engineering" anymore — it's running a research lab where all the researchers are copies of the same model with different instructions. And it worked.

The economics are staggering. Hundreds to low thousands of dollars for a result that represents decades of cumulative human effort. Even with massive survivorship bias (if they tried 100 problems and solved 1), the cost-per-breakthrough is falling through the floor.

The remaining gap is theory-building. As ak_111 pointed out in the thread, this proof works because it's a clever trick — a short argument exploiting known tools in a novel combination. The frontier AI hasn't crossed yet is what mathematicians call "theory-building": proofs like Wiles' proof of Fermat's Last Theorem, which required developing entire new mathematical frameworks across hundreds of pages. AI can find tricks. It can't yet build cathedrals.

The uncomfortable question

If an AI can crack a fifty-year-old conjecture in an hour for $300, what exactly is the moat?

Not the model — GLM-5.2 and DeepSeek V4 are open-weights and approaching frontier performance. Not the compute — it's getting cheaper every month. Not the talent — the prompt was written by a human, but the actual mathematical work was done by the model.

The moat, if there is one, is in the orchestration layer. The prompt. The agent framework. The ability to run 64 parallel searches, maintain diversity, avoid premature convergence, and know when to keep pushing. That's engineering, not science. And engineering, as we've learned from the open-source AI movement, has a way of commoditizing.

This is why tools that give you control over the orchestration — your own agent loops, your own tool access, your own model choice — matter more than ever. You don't need GPT-5.6 Sol Ultra specifically. You need the ability to run the same kind of multi-agent search with whatever model you choose, on your own machine, with your own data.

The proof will be verified or it won't. The multiagent approach will be replicated or it won't. But the pattern is clear: deep, autonomous, long-running AI work isn't a future capability anymore. It's a present one. The question is whether you're set up to use it.

---

If you want to run this kind of deep autonomous work yourself — multi-step agent loops, tool access, model choice — CopperRiver is a desktop AI assistant for Mac that does exactly that. No cloud required.