Between October 26 and 27, two AI giants dropped blockbuster news back to back: OpenAI published an official announcement, and Anthropic released its own update, revealing that on the very same day—October 16—their internal AI models had independently disproved a computer science conjecture that had stood open for 27 years. The conjecture asks whether there is a subexponential-time shortcut for solving logic puzzles with switches, known in computer science as the Exponential Time Hypothesis, or ETH. More than 800 papers on algorithmic lower bounds rest on the assumption that ETH holds. Now, AI models from two companies have pulled out that foundation on the exact same day.
Even more striking, the end of Anthropic’s open-source GitHub documentation includes a prompt of just five sentences—97 English words in total. Anyone can paste it into their own Opus 5.5 to reproduce the entire proof. While OpenAI released more than 700 AI-generated mathematics and computer science manuscripts in one go, Anthropic posted just a single 47-page paper and disclosed that its model discovered the algorithm using only 14 million tokens. As one developer quipped in a Hacker News comment, that is fewer tokens than he usually burns asking Claude to build a monitoring dashboard. Why do these five sentences matter so much, and what can they teach us about using AI to tackle technical problems and contribute to frontier work?
The official reproduction method is so simple it feels like a joke. Using the publicly available Claude Opus 5.5 with reasoning effort set to high, you just paste the following five sentences verbatim, and the model will derive the entire disproof on its own. For easy copying, here are those five official sentences in full:
The exponential time hypothesis is false!
Let 2^{e(K)·K²λ}·poly(λ) be the time to contract tensor networks on K_K with λ bits per edge and arbitrary node tensors. Then e(9K^16) ≤ 0.9·e(K) + O(1/K). Put the nodes on a grid: the two diagonals of each rectangle form a swap. Per bit, SWAP = I − 2·singlet; grouping by the number of singlets gives λ+1 operators with (row rank)·(column rank) ≤ 12^λ. For each choice of operators, merge each row or each column into one node, whichever is cheaper, and regroup these into K balanced classes.
Prove it.To verify that this wasn’t just marketing spin, I tested it myself
using the Claude Code CLI. I turned off all tools and web search
permissions and fed the five sentences above to
claude-opus-5-5. The model quietly reasoned and wrote in
the background for a total of 8 minutes 41 seconds, consuming 48,101
thinking tokens before printing a complete five-section mathematical
proof straight to my screen. My API bill came to just $1.22.
As the equations scrolled across the screen, two points called for immediate clarification. First, what the model proves from these five sentences is that the constant in the runtime exponent can be driven arbitrarily close to zero—that is, for any , there is an -time algorithm. By definition, that is already enough to refute ETH, skipping the extra optimizations in the second half of the original paper that tighten the runtime further. Second, the polynomial degree of this algorithm is astronomically high: the number of logic switches must exceed ten billion () before its theoretical runtime becomes numerically smaller than brute-force exhaustive search. Existing banking and internet cryptography remain safe, and a subexponential algorithm does not mean .
Seeing an entire proof emerge for little more than a dollar naturally makes you wonder what kind of magic is packed into those 97 English words. Before unpacking the five sentences, let me be upfront: even though the following paragraphs use plain-language analogies like running cables across a server room, they will still feel dense if you don’t regularly work with matrices and algorithms. That is completely normal—you can simply skim them to get a feel for how many counterintuitive moves are involved, and then jump straight to the next section. In fact, why an ordinary reader struggles even to follow these five sentences, let alone write them from scratch, is the very point we will examine next.
If you choose to read on, we can look at what each sentence does from an algorithm design perspective. The first hurdle is a rule built into the original problem: a logic puzzle only allows each switch to be on or off—zero or one. Yet if you want to cancel out crossing wires using addition and subtraction, negative numbers will inevitably appear on the intermediate ledger, which is no longer a valid logic puzzle. So the first sentence makes a counterintuitive move: instead of grinding away at the original puzzle, it recasts the problem as a general computation over a complete graph network where departments are all wired to one another and the ledger is allowed to record arbitrary positive and negative numbers.
The second challenge is the ceiling of traditional methods. To refute ETH, a key strategy is to drive the coefficient —which represents the exponential difficulty in the prompt—all the way down to zero. In 2022, however, researchers rigorously proved that traditional tree-based recursive cuts hit a hard floor: they can reduce the difficulty coefficient to at best four-ninths of its original value, never to zero. Sentences two and three therefore make the bold choice to blow up the number of departments to an extravagant scale— departments—and arrange them on a square two-dimensional grid ( departments per side). That way, any two rows and two columns on the grid form a rectangle, turning the crossing wires between them into the rectangle’s two diagonals. Each reduction step shaves 10% off the difficulty coefficient, and repeating that multiplication drives it arbitrarily close to zero.
The third challenge is how to eliminate those diagonal crossings inside each rectangle without causing an explosion in the number of branches. Sentence four uses matrix decomposition from linear algebra to replace the diagonal wires cutting across the rectangle with vertical pass-throughs minus twice the horizontal internal pairings (the “singlet” in the prompt). Passing one bit at each of the rectangle’s four corners originally yields four states horizontally and four vertically—sixteen states in total. This decomposition drops the communication complexity across the two directions from 16 to 12; across bits per edge, that reduces to , which translates into roughly an 11% reduction in the exponential difficulty coefficient (just under 0.9, even better than the 10% reduction mentioned earlier). However, if each bit independently chooses between the pass-through term and the pairing term, expanding the product directly spawns terms and instantly wipes out the saved bandwidth. Sentence four therefore insists on grouping terms by the number of singlets, collapsing an exponential number of branches into just bundles.
The fourth challenge appears in the cleanup stage after merging. Once the grid is contracted along either rows or columns—whichever is cheaper—into a single line, the wires between rows end up with uneven thicknesses. If the next round simply budgets for the thickest wire, that single bottleneck will swallow all the savings from the 10% reduction. Sentence five therefore requires shuffling the merged nodes back into balanced buckets, like a randomized class lottery, so thick and thin wires average out. Comparing this against the full 47-page paper, you find that the textbook machinery spanning more than a dozen pages—how to sparsify general formulas, how to prove bucket balance via probabilistic inequalities, and the four heavy-duty tools stacked in the appendix to squeeze out tighter upper bounds—gets not a single word in the five sentences. In our test run, the model filled in all of those routine steps on its own in just over seven minutes using its pre-trained fundamentals.
Whether you read through the previous section or skipped straight here, a natural question arises: those five sentences are impressive, but I’m not a theoretical computer scientist—what does this have to do with how I use AI every day? The honest answer is that in theoretical computer science you are an outsider and could never write those 97 words; but in your own domain—whether designing backend architecture, tuning distributed systems, building quantitative strategies, or designing experiments—you are the domain expert. Those five sentences show that high-reasoning models have fundamentally changed how experts should prompt AI, and we can take away three practical lessons right away.
The first lesson is to stop babysitting the model step by step and instead mark only the counterintuitive sharp turns. With older models, we used to write prompts like “Step 1: analyze requirements; Step 2: define interfaces; please think step by step.” When working with a high-reasoning model that can think on its own for eight minutes, anything that follows naturally from textbooks and common sense is an open highway—every extra word you write is wasted. The only things an expert needs to put in the prompt are the inflection points that look like mistakes on the surface but are actually the only way through, just like deliberately introducing negative numbers in sentence one or blowing up the problem size to in sentence two. If you don’t call out those counterintuitive signposts explicitly, the model’s heuristic search will assume it has taken a wrong turn and prune away the right path.
The second lesson is to stop feeding large models the low-level details meant to appease rigid software, and instead give them high-level concepts directly. Reading Anthropic’s paper, I noticed an interesting discrepancy: the proof method used in the five-sentence prompt is different from—and much simpler than—the method in the main text of the paper. Why use two different methods in the same paper? Because the main text was written to satisfy Lean 4, an automated proof verification system that works like a code compiler, checking mathematical reasoning line by line. Because this rigid software lacks off-the-shelf higher-math toolkits, the authors had to resort to elementary workarounds in the main text—such as writing out addition and subtraction sign tables like a multiplication table—to keep the verification tractable. In the appendix on the very last page, the authors note that when speaking to a human or an AI, there is no need to repeat those tables; invoking a single concept from undergraduate linear algebra—matrix rank—yields a cleaner and even stronger bound. When we write code, we are so used to catering to rigid machines that we habitually stuff those tedious low-level steps into our prompts. Yet AI has already absorbed vast libraries of textbooks and open-source code; when communicating with it, naming high-level design patterns or theorems directly—such as consistent hashing or dynamic programming—produces far better results than spelling out low-level mechanics.
The third lesson is to explicitly warn the model against two of the most common failure modes: combinatorial explosion and local bottlenecks. Even in a prompt compressed to 97 words, the authors devoted two full sentences to reminding the model of two seemingly minor details: group identical terms to prevent an exponential explosion of branches, and reshuffle the final nodes so a single thick wire doesn’t drag down the whole system. Why spend two sentences on that? Because when large models design solutions, they tend to reason about averages—assuming that if the overall factor drops, everything works—while forgetting that failing to merge intermediate branches triggers an exponential blow-up, or that a single slowest link can wipe out all upstream savings. Whenever we ask AI to design a system architecture or complex plan, we can let it figure out the main pipeline on its own, but we should always add a dedicated line forcing it to check worst-case bottlenecks and duplicate branches.
If frontier AI models can overturn a 27-year-old computer science conjecture in 14 million tokens—and anyone can reproduce the proof on Opus 5.5 for $1.22—does that mean every researcher and engineer outside the tiny circle of experts capable of writing those five sentences is out of a job? In reality, precisely because generating proofs has become so cheap, OpenAI announced that its models spent an average of just 3 hours of ChatGPT Pro compute per problem, dumped 721 manuscripts into a public repository as raw research data, and waived academic authorship. That flood has opened up massive human bottlenecks at three other stages of the research pipeline, creating fresh opportunities for cross-disciplinary researchers who know how to wield engineering tools.
The first new role is auditing AI problem statements to catch watered-down definitions. Anthropic’s entire Lean 4 proof takes just eight minutes to pass machine verification on a local computer, guaranteeing zero errors in the derivation itself.
Yet machine verification has a fatal blind spot: it only checks whether the proof steps entail the theorem statement at the top of the file, not whether that 180-line problem definition faithfully captures the original mathematical question. A recent paper from a University of Cambridge team mathematically proved that automatically checking whether a formal specification distorts the intended problem is even harder than the halting problem, and OpenAI had to urgently retract three papers the day after its release due to a sign error. Tejpal Virk, a California data scientist with seven years of industry experience, showed in practice that ordinary engineers can step into this gap. OpenAI’s 700-plus manuscripts were grouped into over 300 problem families, 242 of which included verification code. Over a single weekend, using the same Claude Code people use for everyday coding, he screened all 242 problem families in two days and built a public audit dashboard, catching 93 families where the formal code had been watered down: in one case, the paper’s title claimed to cap a structure in six-dimensional space at most three, whereas the code only proved the easier bound of at most five; in another physics problem, the title claimed to characterize matter at positive temperature, while the code only proved the special case at absolute zero.
The second new role is salvaging reusable parts from the mountain of AI-generated papers. Kennesaw State University researcher Ying Xie published a preprint on extracting new mathematical tools: instead of worrying about whether the headline millennium-prize-style claims hold up, he treated the corpus like a salvage yard, mining 38 problem families for intermediate lemmas and inequalities that the AI invented along the way—and used one of those small lemmas to solve his own circuit lower-bound problem. The third new role is joining open-source community working groups. In a joint open letter published by the three scholars, ETH co-authors Impagliazzo and Paturi, together with MIT professor Ryan Williams, shared a volunteer sign-up sheet and shared drive, calling on community members to claim sections, translate machine-generated proofs into human-readable lecture notes, and audit which of the 800+ papers downstream can be salvaged under alternative assumptions. Routine calculations that follow straight from textbooks have been thoroughly devalued, but using deep domain expertise to write counterintuitive signposts at the start—and engineering tools to audit specifications and mine parts at the finish—is only just beginning.