OpenAI Claims Reasoning Model Disproved 30-Year Computing Complexity Theory

Theoretical computer science was rocked on October 26, 2026, when OpenAI published a 67-page manuscript bluntly titled The Exponential Time Hypothesis is False. Accompanied by machine-checked code written in the Lean formal verification language, the paper claimed that an internal OpenAI reasoning model had constructed a counterexample disproving the Exponential Time Hypothesis (ETH)—a foundational conjecture that has dictated the boundaries of algorithmic speed and computational limits for nearly three decades.

The hypothesis, formulated in 1999 by computer scientists Russell Impagliazzo and Ramamohan Paturi, asserts that the classic Boolean satisfiability problem known as 3-SAT cannot be solved in subexponential time. For 27 years, hundreds of academic papers have treated this proposition not merely as a curiosity, but as an indispensable working axiom. Researchers have relied on it as an architectural bedrock to establish conditional lower bounds across graph theory, computational biology, database query optimization, network routing, and cryptography. If the Exponential Time Hypothesis fails, an entire branch of theoretical computer science—known as fine-grained complexity—faces an immediate recalculation of what is possible, what is impossible, and how fast automated reasoning can become.

OpenAI reported that the AI system generated the natural-language disproof on October 16, 2026. By the following day, the proof was translated and syntactically verified within Lean, an automated proof assistant designed to mathematically certify every inferential step. Rather than claiming unilateral victory, OpenAI took the unprecedented step of enlisting the conjecture’s original creators to test its validity. A triage group led by Impagliazzo and Paturi of the University of California, San Diego, alongside Massachusetts Institute of Technology complexity theorist Ryan Williams, agreed to organize an independent, open review of the machine-generated work.

"If the claim is correct, it will change an important part of theoretical computer science," the three theorists wrote in a joint letter to the academic community. "The hypothesis has helped organize decades of research, connecting problems and sharpening our understanding of computational limits". Paturi candidly remarked that when he first received the AI’s disproof of his own life’s work, his instinctive reaction was total disbelief. "Not participating in the examination of a claim this important is unthinkable," Paturi added. "Examining, questioning, explaining, and building on one another's work is central to how science advances".

OpenAI accompanied the release by placing all underlying raw datasets and formal mathematical scripts into an open-access repository, while committing $5 million to the Simons Foundation to fund international workshops where researchers can collectively dissect the proof. The event marked one point in a tripartite release from OpenAI that day: its systems also claimed full-dimensional solutions to the geometric Kakeya and local smoothing conjectures in pure mathematics, as well as an existence proof for pure Yang-Mills gauge theories in mathematical physics. Yet it was the computational claim that ignited the most immediate scrutiny. To understand why an algorithm challenging an abstract logic hypothesis has sent shockwaves through the global computing community, one must strip away the high-level rhetoric and examine the intricate mechanics of complexity theory itself.

       COMPUTATIONAL COMPLEXITY LANDSCAPE
+-------------------------------------------------------+
|  EXPTIME (Exponential Time)                           |
|  Problems solvable in 2^(n^c) steps                   |
|                                                       |
|   +-----------------------------------------------+   |
|   |  NP (Nondeterministic Polynomial Time)        |   |
|   |  Solutions easily verified in O(n^c) steps    |   |
|   |                                               |   |
|   |   +---------------------------------------+   |   |
|   |   |  NP-Complete (The Hardest NP)         |   |   |
|   |   |  3-SAT, Traveling Salesperson, etc.   |   |   |
|   |   |                                       |   |   |
|   |   |   Classic Assumption (ETH):           |   |   |
|   |   |   Required Time = 2^(c * n)           |   |   |
|   |   |                                       |   |   |
|   |   |   AI Claimed Refutation:              |   |   |
|   |   |   Subexponential Time = 2^(o(n))      |   |   |
|   |   +---------------------------------------+   |   |
|   |                                               |   |
|   |   +---------------------------------------+   |   |
|   |   |  P (Polynomial Time)                  |   |   |
|   |   |  Solvable quickly: O(n^c)             |   |   |
|   |   +---------------------------------------+   |   |
|   +-----------------------------------------------+   |
+-------------------------------------------------------+

The Combinatorial Abyss: Why Easy-Looking Problems Break Modern Computers

At the center of computer science lies a brutal mathematical reality known as combinatorial explosion. When software sorts an alphabetized list of names, searches through a directory, or calculates the shortest route between two intersections on a map using standard graph traversal, it executes tasks in polynomial time. In computer science terminology, polynomial time is categorized as class P. If a problem has an input size of $n$ elements, the number of basic computational steps required to solve it scales cleanly as $n$, $n^2$, or $n^3$. Double the input size, and the computer works four or eight times as long—a linear or quadratic penalty that modern silicon chips absorb in fractions of a millisecond.

Beyond class P lies a vast expanse of problems whose solutions are trivial to check once found, but extraordinarily punishing to discover from scratch. This domain is known as NP, or Nondeterministic Polynomial time. Consider a Sudoku puzzle. If someone gives you a completed grid, checking that every row, column, and three-by-three block contains the digits one through nine requires only a few seconds of basic scanning. But if you are handed an empty 100-by-100 Sudoku grid, locating that single valid configuration demands navigating a branching labyrinth of choices.

This divergence is the heart of the Boolean Satisfiability Problem, or SAT. In a SAT problem, a computer is given a boolean logical formula consisting of binary variables (switches that can only be set to TRUE or FALSE), grouped together using logical AND ($\land$), OR ($\lor$), and NOT ($\neg$) operations. The machine’s goal is to determine whether there exists at least one single master configuration of true and false switches that satisfies every single clause simultaneously.

In 1971, computer scientist Stephen Cook published a paper that established the foundations of modern theoretical computer science: SAT is NP-complete. A year later, Richard Karp demonstrated that 21 diverse computational challenges—spanning the Traveling Salesperson Problem, graph coloring, clique detection, and set packing—could all be translated directly into SAT. NP-complete problems are universal chameleons. If you develop an algorithm capable of solving SAT in lightning-fast polynomial time, that same algorithm can instantly solve every single one of the thousands of NP problems across medicine, logistics, cryptography, and structural engineering.

       THE COOK-LEVIN REDUCTION HIGHWAY
       
     [ Traveling Salesperson ] ---------\
     [ Protein Folding       ] ----------\
     [ Graph 3-Coloring      ] -----------> [ Boolean 3-SAT ]
     [ Integer Programming   ] -----------/
     [ Circuit Minimization  ] ---------/
     
   Solving 3-SAT subexponentially implies
   faster algorithms for every problem connected to it.

To standardize these formulas, mathematicians group logic into "Conjunctive Normal Form" (CNF). In 3-SAT, every condition is an OR clause containing exactly three variables, such as:

$$(x_1 \lor \neg x_2 \lor x_3) \land (\neg x_1 \lor x_4 \lor \neg x_5) \land (x_2 \lor \neg x_3 \lor x_5)$$

If you have 10 variables, there are $2^{10} = 1,024$ possible assignments of true and false. A laptop checks them in the blink of an eye. If you have 100 variables, the space of possibilities surges to $2^{100}$, which equals roughly $1.26 \times 10^{30}$ configurations. Even a supercomputer testing a trillion assignments per second would run for tens of billions of years—longer than the age of the universe—without coming close to finishing a brute-force sweep.

For half a century, the famous P versus NP question has asked whether some hidden mathematical trick exists that allows computers to bypass this combinatorial wall and solve NP-complete problems in polynomial time. While that question remains unresolved, complexity theorists realized decades ago that treating all slow problems as equally hard was insufficient. They needed to measure the precise texture of the wall itself.

The Birth of the Exponential Time Hypothesis

By the late 1990s, computer scientists had largely despaired of proving whether P equals NP. The problem was too broad, and mathematical techniques were too blunt. Attention shifted toward developing a more granular, fine-grained understanding of exact algorithm speeds. Theorists asked an inverse question: assuming that P does not equal NP, precisely how hard is 3-SAT in the worst-case scenario?

Could an ingenious mathematician devise an algorithm that solves an $n$-variable 3-SAT problem in $2^{\sqrt{n}}$ steps? While $2^{\sqrt{n}}$ is technically slower than polynomial time (meaning it does not place the problem in P), it grows far more slowly than a pure exponential function like $2^{0.5n}$ or $2^n$. If $n = 10,000$, a pure exponential calculation of $2^n$ is an unapproachable mathematical abstraction. Yet $\sqrt{10,000} = 100$, bringing $2^{\sqrt{n}}$ down to $2^{100}$—an enormous number, but one that falls within the theoretical perimeter of planetary-scale computing.

In 1999, Russell Impagliazzo and Ramamohan Paturi, later joined by Francis Zane, formulated the Exponential Time Hypothesis (ETH). Rather than leaving the question open, ETH planted a definitive stake in the mathematical ground:

The Exponential Time Hypothesis (Formal Statement):

For every integer $k \ge 3$, define $s_k$ as the infimum of real numbers $\delta$ such that there exists an algorithm solving $k$-SAT in $O(2^{\delta n})$ time, where $n$ is the number of variables. The hypothesis conjectures that for all $k \ge 3$:

$$s_k > 0$$

In non-technical language, ETH states that there is no algorithmic trick, no shortcut, and no structural loophole that can eliminate the exponential scaling of 3-SAT. The hypothesis asserts that the worst-case runtime is strictly locked behind a wall of $2^{c n}$, where $c$ is a positive constant strictly greater than zero. It explicitly forbids the existence of an algorithm running in subexponential time, formally written as:

$$2^{o(n)}$$

Any mathematical function designated as $o(n)$ (read as "little-o of n") grows strictly slower than a linear multiple of $n$. Common examples of subexponential growth functions include:

$2^{c \sqrt{n}}$
$2^{c n^{0.99}}$
$2^{c \frac{n}{\log n}}$
$2^{c \frac{n}{\log \log n}}$

                        RUNTIME GROWTH VISUALIZED
 Steps
   ^
   |                                          / (Pure Exponential: 2^(0.5n) - ETH Holds)
   |                                         /
   |                                        /
   |                                       /
   |                                      /   / (Subexponential: 2^(sqrt(n)) - AI Claim)
   |                                     /   /
   |                                    /   /
   |                                   /   /
   |                                  /   /
   |                                 /   /
   |                                /   /
   |                               /   /
   |                              /   /
   |                             /   /
   |                            /   /
   |                           /   /       ________________ (Polynomial: n^3 - Class P)
   |                          /   /       /
   +----------------------------------------------------------> Input Variables (n)

Impagliazzo and Paturi followed this conjecture by proposing an even stricter companion: the Strong Exponential Time Hypothesis (SETH). SETH posits that as the length of the clauses $k$ increases (moving from 3-SAT to 4-SAT, 5-SAT, and onward), the constant $s_k$ must relentlessly climb toward 1:

$$\lim_{k \to \infty} s_k = 1$$

Under SETH, an algorithm solving general SAT cannot outsmart brute-force search; testing an arbitrary formula requires checking essentially the full combinatorial space of $2^n$ assignments.

For nearly 30 years, ETH and SETH served as the foundational bedrock for an entire architectural domain of computing known as fine-grained complexity theory. When algorithm designers attempted to tackle notoriously difficult problems—such as the Fréchet distance between curves, string edit distance in computational genomics, or longest common subsequence problems—they frequently found themselves unable to break past certain quadratic ($n^2$) or cubic ($n^3$) barriers.

To explain why, researchers relied on reductions anchored to ETH. A computer scientist would write: "Assuming the Exponential Time Hypothesis is true, Problem X cannot be solved faster than $O(n^2)$." Hundreds of doctoral dissertations, thousands of peer-reviewed proofs, and foundational theorems across algorithm design rested upon this single pillar.

It was this pillar that the OpenAI reasoning model targeted.

What OpenAI Claims Its AI Model Discovered

According to technical documentation released alongside OpenAI’s public code repository, an internal OpenAI reasoning model produced a formal mathematical write-up purporting to demonstrate that the Exponential Time Hypothesis is structurally false. The machine did not just deliver a decision algorithm that outputs a binary YES or NO as to whether a formula can be satisfied; its proof established an algorithm for #3-SAT (Sharp-3-SAT)—the computationally strictly harder challenge of counting the exact number of distinct satisfying truth assignments for an arbitrary formula.

       THE EXTENT OF THE MODEL'S REFUTATION
       
       Decision Problem:               Counting Problem (#SAT):
   "Does at least ONE solution      "How many TOTAL valid solutions
         exist? (Yes/No)"                 exist in the system?"
                |                                   |
                v                                   v
         Traditional ETH                   Deeper Complexity
        Refutation Target                  Claimed by OpenAI AI
                \                                   /
                 \                                 /
                  v                               v
             The algorithm operates in Deterministic Subexponential Time:
                            Runtime = 2^(o(n))

In the documentation formalizing the proof, OpenAI stated that for any fixed clause length $k \ge 2$, a deterministic Turing machine can calculate the exact count of satisfying assignments for a canonically encoded $k$-CNF boolean formula on $n$ variables in subexponential time using only polynomial memory space:

$$\text{Time} \le 2^{o(n)}, \quad \text{Space} \le \text{poly}(n)$$

Because the ability to count solutions inherently proves whether at least one solution exists (if the count is greater than zero, the formula is satisfiable), the algorithm immediately refutes the baseline Exponential Time Hypothesis. If $s_3 = 0$, then 3-SAT can be systematically cracked in subexponential time. And because refuting ETH invalidates the lower bound for all $k \ge 3$, the Strong Exponential Time Hypothesis instantly collapses with it.

Deconstructing the Disproof Strategy

How does an algorithm breach a 27-year-old combinatorial barrier? While computer scientists around the world are currently working through the 67-page text to verify its foundational integrity, the underlying methodology relies on identifying structural vulnerabilities within the clause-variable graphs of boolean formulas.

Traditional brute-force solvers evaluate variables sequentially: assign $x_1 = \text{TRUE}$, simplify the remaining equations, and branch recursively. When an algorithm encounters a contradiction, it backtracks. Even modern, highly optimized industrial solvers—known as Conflict-Driven Clause Learning (CDCL) solvers—frequently encounter "hard" instances where the underlying formula mimics a mathematical expander graph. In these scenarios, every choice cascades into widespread ambiguity, forcing the algorithm to explore vast exponential swathes of the search tree.

The counterexample produced by the OpenAI reasoning model sidesteps this trap through a multi-tiered decomposition framework:

Hypergraph Decomposition and Variable Partitioning: Rather than treating variables as interchangeable logical tokens, the algorithm translates the boolean formula into an algebraic hypergraph, where clauses represent multi-dimensional edges connecting variable nodes. The model demonstrates that every $k$-CNF instance contains topological bottlenecks. By isolating small subsets of variables that act as structural bridges, the system fractures the hypergraph into weakly interacting clusters.
Dynamic Algebraic Interpolation: Instead of recursively checking combinations across these clusters, the algorithm maps the sub-problems into polynomials over finite fields. By evaluating these polynomials at a carefully calibrated sequence of algebraic coordinates, the machine extracts exact assignment counts using multivariate interpolation.
Sub-Linear Sparsification: Historically, the Sparsification Lemma—proven by Impagliazzo, Paturi, and Zane in 1999—showed that any general $k$-CNF formula can be expressed as a disjunction of formulas with a linear number of clauses ($m \le c \cdot n$). The AI model’s paper introduces an algebraic shortcut that reduces the clause density dynamically, allowing the search space to scale asymptotically at $2^{O(n / \log \log n)}$ or $2^{O(n^{1 - \epsilon})}$ rather than $2^{c n}$.

The moment the exponent drops below a strict linear relationship to $n$—even by a fractional power or a sub-linear logarithmic denominator—the Exponential Time Hypothesis is mathematically demolished.

Machine Checking: The Crucial Role of the Lean Theorem Prover

In theoretical computer science and pure mathematics, extraordinary claims are routinely met with deep skepticism. Over the past several decades, hundreds of preprints have claimed to prove that P equals NP, or that P does not equal NP. The vast majority contain subtle algebraic flaws, undetected circular reasoning, or misapplications of reductions within the first ten pages.

What stopped researchers from immediately dismissing the claim made by the OpenAI reasoning model was a critical accompanying artifact: a complete formalization written in Lean.

               HOW A PROOF ASSISTANT OPERATES
               
    [ Human / AI Written Paper ]
    Contains natural language explanations, intuitive analogies,
    and high-level mathematical steps.
                 |
                 v
    [ Formal Translation into Lean ]
    Every definition, variable, lemma, and step translated into 
    strict type-theoretic computational code.
                 |
                 v
    [ The Lean Micro-Kernel ]
    A minimal, rock-solid software core that checks:
    Does Step B follow from Step A according to foundational axioms?
                 |
        +--------+--------+
        |                 |
        v                 v
   [ TYPE ERROR ]     [ ACCEPTED ]
   Gap in logic!      Syntactically certified
   Proof rejected.    zero logical errors.

Understanding Interactive Theorem Provers

Lean is an open-source programming language and interactive theorem prover developed by Leonardo de Moura at Microsoft Research in 2013, now maintained as Lean 4 by the Lean FRO (Focused Research Organization). Unlike traditional software, Lean does not simply run calculations or execute application scripts. Instead, it operates on the mathematical framework of dependent type theory (specifically, the Calculus of Inductive Constructions).

In Lean, mathematical statements—such as "The Exponential Time Hypothesis is False"—are represented as types, and mathematical proofs are written as programs whose execution constructs an object of that exact type. This methodology is founded upon the Curry-Howard Correspondence, an established mathematical principle demonstrating that an absolute structural equivalence exists between logical propositions and computer data types:

$$\text{Proposition} \iff \text{Type}$$

$$\text{Proof} \iff \text{Program (Term)}$$

When a proof is fed into Lean, the code is evaluated by an ultra-lean, rigorously audited software component called the proof kernel. The kernel does not care about the fame of the author, the prestige of the institution, or the historical consensus of theoretical computer scientists. It parses every single inferential step with absolute algorithmic literalism. If a mathematician asserts that Step 4 follows from Step 3, the Lean kernel validates whether that specific inference follows strictly from the formal axioms of mathematics (such as Zermelo-Fraenkel set theory with the Axiom of Choice). If there is a single skipped step, an undefined variable, a division by zero, or an unproven logical leap, Lean throws a compilation error and rejects the entire file.

OpenAI disclosed that after the internal reasoning model generated the initial natural-language proof on October 16, a secondary pipeline translated the formal argument into Lean syntax by October 17. The proof compiled cleanly without errors.

The Specification Problem: Can a Verified Proof Still Be Wrong?

To the general public, a machine-checked proof sounds like undeniable validation. If a deterministic verification kernel confirms that the code compiles, does that not guarantee that the Exponential Time Hypothesis has fallen?

Theoretical computer scientists emphasize that machine checking introduces a distinct verification challenge known as the specification problem.

                THE SPECIFICATION HAZARD
                
           Is the Mathematical Definition Correct?
           
      Lean Kernel Validates:             Human Skepticism Asks:
   "The internal logical steps       "Did the author define 3-SAT,
    from Line 1 to Line 10,000        Turing Machines, and ETH in
       are entirely sound."           Lean correctly, or is there an
                                      accidental loophole?"

The Lean kernel only confirms that a program satisfies its explicit programmatic definitions. It cannot verify whether the programmer’s formal definitions accurately represent the physical or mathematical reality intended by human scientists. Historically, several avenues for subtle errors have surfaced during formal verification projects:

Vacuous Truths: If a foundational premise is inadvertently defined with a contradictory condition (for example, defining a formula structure that accidentally requires $n$ to be simultaneously even and odd), the mathematical premise becomes empty. In formal logic, any statement derived from an impossible premise is automatically "true" ($P \implies Q$ is trivially true if $P$ is false). A proof assistant will compile this code successfully, even though the conclusion is mathematically meaningless in the real world.
Definitional Mismatches: Did the AI model define a deterministic Turing machine, computational runtime, and subexponential growth in Lean precisely as Impagliazzo and Paturi did in 1999? If the formalization altered even a subtle constraint—such as how memory space is bounded, how the input string is encoded on the tape, or how the asymptotic limit of little-o notation is evaluated at the boundary—the system might have proven a correct theorem about a slightly different mathematical object, leaving the actual real-world hypothesis untouched.
The Proof Assistant Trusted Base: While the Lean kernel is exceptionally small (only a few thousand lines of audited code), it rests on an operating system, a hardware architecture, and a compiler. While a bug within the core Lean kernel is considered rare by modern computer scientists, verifying the macro-definitions within the thousands of lines of auxiliary code requires extensive human scrutiny.

This specification boundary explains why theoretical computer scientists did not immediately declare the problem solved. The proof assistant confirmed that the 67-page argument contains zero internal logical gaps within its own defined world. The remaining task for human theorists is to determine whether the AI's defined world matches our physical and mathematical reality.

The Academic Response: Creators Called to Judge Their Own Theory

The sheer speed of OpenAI’s theoretical claims has sent shockwaves through the academic community. In early October 2026, OpenAI published a deluge of 722 machine-generated mathematical manuscripts tackling conjectures from the famous Erdős problem database. That uncurated data drop drew fierce pushback from academic mathematicians, who complained that academic departments were being inundated by a firehose of unverified AI preprints that human reviewers could not possibly digest.

Recognizing that dumping complex theoretical computer science manuscripts onto open preprint servers risks alienating the scientific community, OpenAI adopted a completely restructured distribution strategy for its October 26 release. The company devised an external shepherd model, reaching out to leading independent domain authorities to organize open review panels before public release.

              THE SHEPHERD REVIEW FRAMEWORK
              
               [ OpenAI Research Team ]
                          |
             Outputs AI-Generated Proofs
                          |
                          v
         [ Independent External Shepherd Panel ]
           - Russell Impagliazzo (UCSD)
           - Ramamohan Paturi (UCSD)
           - Ryan Williams (MIT)
                          |
        +-----------------+-----------------+
        |                                   |
        v                                   v
   No Nondisclosure                 Zero Academic Credit
   Agreements (NDAs)                Sought by OpenAI
   Complete Independence            Researchers Retain Full Voice
        |                                   |
        +-----------------+-----------------+
                          |
                          v
     [ Global Theoretical Computer Science Community ]
         Public GitHub Data + Simons Foundation Workshops

For the Exponential Time Hypothesis disproof, OpenAI invited three of the world’s foremost authorities on fine-grained complexity: Russell Impagliazzo and Ramamohan Paturi—the very theorists who created the hypothesis in 1999—alongside MIT professor Ryan Williams, renowned for his breakthroughs in circuit complexity and algorithmic lower bounds.

Williams immediately addressed the academic community via public social channels, clarifying the terms under which the review panel agreed to engage with OpenAI:

No Financial Compensation: The researchers are serving entirely unpaid, preserving absolute scientific objectivity.
No Nondisclosure Agreements: The panel signed no NDAs, retaining the unconditional right to publish their findings, criticize the proofs, or point out fatal flaws without corporate pre-clearance.
Open Access to Raw Data: OpenAI agreed to open-source all internal model prompts, intermediary scratchpads, and execution traces that yielded the proof.
Conference Funding: OpenAI committed $5 million directly to the Simons Foundation to establish structured, human-led academic workshops to independently dissect the mathematical implications.
No Authorship Claims: OpenAI confirmed it is not seeking formal academic authorship or priority claims for its corporate employees, acknowledging that scientific understanding belongs to the researchers who analyze, explain, and contextualize the findings.

"Our involvement should not be taken as certification of the claim," warned Impagliazzo, Paturi, and Williams in their joint message. "A result of this significance requires careful, independent scrutiny".

The intellectual drama of this arrangement is historic. Paturi and Impagliazzo find themselves in the extraordinary position of acting as formal arbiters over an artificial intelligence that claims to have rendered their namesake theoretical framework obsolete.

Untangling the Technical Confusion: What the Disproof Does and Does Not Mean

Whenever an announcement touches upon boolean logic, computational complexity, and OpenAI, widespread confusion inevitably erupts across technology hubs and financial markets. It is vital to articulate precisely what this claimed breakthrough represents, and just as importantly, what it explicitly does not.

+---------------------------------------------------------------------------------------+
|                               MISCONCEPTION VS. REALITY                                |
+---------------------------------------------------------------------------------------+
|  THE POPULAR MYTH:                                                                    |
|  "OpenAI's AI solved P vs NP, meaning all computer encryption has been instantly      |
|   broken and internet security is obsolete."                                          |
|                                                                                       |
|  THE MATHEMATICAL REALITY:                                                            |
|  P vs NP remains entirely untouched. Refuting ETH shows an algorithm running in       |
|  subexponential time: 2^(o(n)). This is vastly slower than polynomial time: O(n^c).    |
|  Modern cryptography remains secure against these theoretical algorithms.             |
+---------------------------------------------------------------------------------------+

1. P vs NP is Not Solved

The disproof of the Exponential Time Hypothesis does not prove that P equals NP.

Proving that P equals NP requires demonstrating that an NP-complete problem like 3-SAT can be solved in polynomial time: $O(n^c)$ for some constant $c$. If an algorithm requires $n^2$ or $n^3$ steps, it belongs to P.

The algorithm produced by the OpenAI system operates in subexponential time: $2^{o(n)}$. While subexponential time grows much slower than pure exponential time ($2^{c n}$), it is still asymptotically vastly larger than any polynomial function. Greg Brockman, president of OpenAI, explicitly underscored this boundary upon release, stating that the result provides zero evidence that P equals NP, reaffirming the prevailing scientific consensus that P almost certainly does not equal NP.

  Complexity Growth Hierarchy (from fastest to slowest):
  
  [ P: Polynomial Time ]       -> n, n^2, n^3              (Tractable, Fast)
          |
          v
  [ Subexponential Time ]      -> 2^(sqrt(n)), 2^(n/log n) (AI Claim - Asymptotically
          |                                                 faster than pure exponents,
          v                                                 yet still astronomically huge)
  [ Exponential Time (ETH) ]   -> 2^(0.1n), 2^(n)          (Combinatorial Brick Wall)
          |
          v
  [ Factorial Time ]           -> n!                       (Worst Brute Force)

2. Encryption is Not Compromised Overnight

Modern internet commerce, blockchain architectures, and defense infrastructure rely heavily on public-key cryptography—principally RSA, Elliptic Curve Cryptography (ECC), and newly deployed Post-Quantum Cryptography standards (such as lattice-based cryptography approved by the National Institute of Standards and Technology).

RSA and Elliptic Curves depend on the mathematical hardness of integer factorization and the discrete logarithm problem. Neither of these challenges is NP-complete; they reside in intermediate complexity classes (and can be cracked in polynomial time by large-scale quantum machines running Shor’s Algorithm, which is completely unrelated to classical subexponential 3-SAT solvers).
Lattice-Based Cryptography (such as CRYSTALS-Kyber) relies on problems like the Shortest Vector Problem (SVP), which are grounded in worst-case lattice hardness. While structural breakthroughs in subexponential algorithms warrant careful monitoring by cryptographers, classical security keys of 256 bits or 2,048 bits maintain combinatorial defense thresholds that dwarf these theoretical scaling gains.

3. Asymptotics versus Real-World Run Times: Galactic Algorithms

In theoretical computer science, a mathematical algorithm can achieve an asymptotic improvement while remaining entirely useless on physical hardware. Such constructions are formally termed galactic algorithms.

Consider an algorithm that runs in subexponential time $2^{\sqrt{n}}$, but features a hidden structural coefficient of $10^{100}$:

$$\text{Steps} = 10^{100} \cdot 2^{\sqrt{n}}$$

As $n$ tends toward infinity, this formula is mathematically and asymptotically superior to an algorithm running in $2^{0.0001n}$ steps. In a theoretical paper, the subexponential algorithm wins, proving that the Exponential Time Hypothesis is false. But in the physical universe, for any problem size humans could ever input into a computer (say, $n = 100,000$), the "faster" theoretical algorithm would require more steps than the number of subatomic particles in the observable galaxy.

OpenAI explicitly highlighted this distinction in its initial disclosure: "Challenging a computational complexity hypothesis does not mean existing software will suddenly run faster or that complex problems will become easier to solve". Finding practical, real-world algorithms based on these theoretical insights will demand extensive further research.

Fine-Grained Complexity: The Dominoes That Fall If ETH Collapses

While software engineers writing enterprise web applications will see no immediate changes to their codebases tomorrow, the refutation of ETH triggers an intellectual earthquake across algorithm theory.

For the past quarter-century, fine-grained complexity theorists have built a sprawling taxonomy of conditional hardness. Because proving that an algorithm is mathematically impossible is notoriously challenging, theorists routinely prove conditional barriers. They formulate mathematical chains of logic:

$$\text{If ETH is TRUE} \implies \text{Problem X cannot run faster than } T(n)$$

If the anchor of this logical chain snaps, every conclusion suspended beneath it falls into theoretical ambiguity.

                     THE DOMINO EFFECT OF REFUTING ETH
                     
                [ Exponential Time Hypothesis (ETH) ]
                     FALLS / PROVEN FALSE
                               |
         +---------------------+---------------------+
         |                                           |
         v                                           v
[ Parameterized Complexity ]               [ Fine-Grained Lower Bounds ]
Hardness bounds for:                       Tight execution bounds for:
- Vertex Cover                             - Frechet Distance (Geometry)
- Independent Set                          - Longest Common Subsequence
- Graph Coloring                           - Edit Distance (Bioinformatics)
- Dominating Set                           - Database Query Joins
         |                                           |
         +---------------------+---------------------+
                               |
                               v
               The fundamental question reopens:
         Can these real-world challenges be solved 
         exponentially faster than humans presumed?

Consider the concrete computational domains directly impacted by this theoretical collapse:

Computational Biology and Genomic Alignment

Modern DNA sequencing relies heavily on sequence alignment algorithms that calculate the edit distance between genetic sequences. Researchers proved years ago that calculating the exact edit distance between two strings of length $n$ cannot be achieved in sub-quadratic time (faster than $O(n^{2 - \epsilon})$) under the Strong Exponential Time Hypothesis. If SETH and ETH are invalid, the theoretical wall blocking the creation of ultra-fast, sub-quadratic genomic comparison algorithms dissolves, opening the door for bioinformaticians to search for faster algorithms that were previously assumed to be mathematically impossible.

Dynamic Programming and Database Infrastructure

Modern database systems spend billions of dollars in compute cycles optimizing relational joins. Under SETH, researchers proved hard bounds demonstrating that specific types of regular expression matching and graph-based database queries cannot run fundamentally faster than their current baseline implementations. A refutation of ETH resets these assumptions, forcing algorithm designers to reopen decades-old research files.

Operations Research and Network Routing

Problems ranging from routing delivery vehicle fleets to laying out microscopic pathways on semiconductor silicon microchips are variants of NP-complete graph problems (such as the Traveling Salesperson Problem, Hamiltonian Path, or Steiner Tree). Under ETH, algorithm designers accepted that calculating exact optimal paths for large graphs was fundamentally out of reach, forcing the industry to settle for approximate heuristics. If 3-SAT admits a subexponential solution, every NP-complete problem does. While the constants may initially be galactic, the theoretical pathway to exact, optimal solutions for massive industrial logistical graphs has been cleared.

How Frontier AI Models Are Changing Theoretical Mathematics

The disproof of the Exponential Time Hypothesis is not an isolated event. It represents a dramatic inflection point in how generative artificial intelligence and theoretical science intersect.

Over the past four years, machine learning evolved from basic natural language text generation to the development of dedicated reasoning architectures. The deployment of the OpenAI reasoning model family demonstrated that models can utilize dynamic test-time compute: generating thousands of internal logical steps, self-correcting mistakes, exploring parallel hypothesis trees, and backtracking when a deduction hits a dead end.

                  THE EVOLUTION OF AI IN MATHEMATICS
                  
   Phase 1: Pattern Imitation (Pre-2024)
   - Large Language Models trained on standard text corpora.
   - Excelled at summarizing papers, writing boilerplate Python.
   - Hallucinated equations, made basic arithmetic errors.
   - Incapable of rigorous logic.
                  |
                  v
   Phase 2: Test-Time Reasoning Engines (2024–2025)
   - Introduction of reasoning models using internal chain-of-thought search.
   - Competitive programming success (International Mathematical Olympiad medals).
   - Capable of catching logical bugs, synthesizing known proofs.
                  |
                  v
   Phase 3: Formal Synthesis and Auto-Formalization (Late 2026)
   - Continuous closed-loop interaction with Lean and Isabelle kernels.
   - AI outputs natural-language proofs AND auto-formalizes them.
   - Directly attacks decades-old, open conjectures in complexity, geometry, and physics.
   - Produces raw mathematical discoveries at an unprecedented cadence.

By connecting an OpenAI reasoning model directly to an interactive theorem prover like Lean, researchers establish a closed-loop synthetic research environment. When the language model generates an algorithmic reduction or proposes an auxiliary mathematical equation, it does not have to guess whether its step is correct. The theorem prover checks the step, identifies errors, and returns programmatic feedback to the model. The AI then iterates, exploring alternative paths through mathematical hyperspace until the entire deductive chain compiles cleanly.

This workflow led directly to OpenAI’s staggering October 26 triple release:

Computer Science: Refutation of the Exponential Time Hypothesis.
Harmonic Analysis and Geometry: Settlement of Christopher Sogge’s 1991 Local Smoothing Conjecture in all spatial dimensions using an auxiliary partial differential equation. Through mathematical deduction, this proof simultaneously settles the historic Kakeya needle conjecture (calculating the minimal volume of a space in which a unit needle can be rotated 360 degrees) and Stein’s restriction conjecture across all dimensions at once. University of Rochester mathematics professor Alex Iosevich termed the breakthrough a historic milestone that will fundamentally change theoretical research.
Theoretical Physics: Construction of a mathematically rigorous existence proof for pure Yang-Mills gauge theory and quantum chromodynamics (QCD) in four-dimensional space—directly engaging the existence half of the Clay Mathematics Institute’s Millennium Prize Problem.

The velocity of these developments has created profound tension within the scientific establishment. In traditional academia, a single human researcher might spend an entire 40-year career mastering the tools necessary to chip away at one dimension of the Kakeya conjecture or prove a specialized sub-case of the Exponential Time Hypothesis. An automated system generating comprehensive preprints for three landmark problems across three separate fields in the span of a single month completely disrupts standard academic evaluation.

What to Watch Next: The Milestones of Human Verification

As the international computing community begins the painstaking work of dissecting OpenAI’s 67-page manuscript and its companion Lean repository, the scientific world enters an unprecedented holding pattern. Over the coming months, several critical milestones will indicate whether this claimed disproof of the Exponential Time Hypothesis will stand as an algorithmic landmark or be remembered as an instructive near-miss:

               THE VERIFICATION TIMELINE: KEY PHASES
               
   [ Phase 1: Formal Audit of Lean Definitions ] <--- WE ARE HERE
   The community inspects the Lean code: Did the model define
   3-SAT, asymptotic notation, and Turing machines accurately?
   Are there any vacuous logical shortcuts?
                      |
                      v
   [ Phase 2: Natural-Language Translation & Explanation ]
   The shepherd panel (Impagliazzo, Paturi, Williams) translates
   the 67-page dense technical argument into an accessible,
   intuitive theoretical paper readable by general computer scientists.
                      |
                      v
   [ Phase 3: The Simons Foundation Global Workshops ]
   Funded academic symposia where leading complexity theorists
   gather to stress-test the hypergraph decomposition techniques.
                      |
                      v
   [ Phase 4: Definitive Academic Consensus ]
   The proof is either formally ratified, modified into a partial
   advance, or rejected due to a critical definitional flaw.

Critical Questions the Community Must Resolve

Does the algorithm contain a hidden specification error in Lean? Theoretical computer scientists are already auditing the introductory declarations of the code repository. The primary question is whether the AI’s formalization of $k$-CNF satisfiability matches the universal formulation used in the Cook-Levin theorem and standard complexity textbooks.
What are the exact constants in the subexponential exponent? Is the model’s asymptotic scaling $2^{O(n / \log n)}$, $2^{O(\sqrt{n})}$, or something far closer to the linear boundary? The practical relevance of the algorithm hinges entirely on whether the exponent can be engineered into feasible real-world compute envelopes.
Can the hypergraph reduction technique be generalized? If the OpenAI reasoning model’s approach to tearing down 3-SAT formulas is mathematically sound, can that identical structural tool be repurposed to attack other notorious unsolved challenges, such as the Graph Isomorphism problem, or provide tighter bounds on the Unique Games Conjecture?
How will the sociology of science adapt? The establishment of OpenAI’s shepherd review process represents an initial experiment in handling machine-generated breakthroughs. If independent researchers must spend thousands of unpaid hours auditing dense, highly complex AI manuscripts, the academic publishing and grant allocation systems will require fundamental reform.

The claimed refutation of the Exponential Time Hypothesis marks a profound turning point in the history of science. A conjecture that provided stability, organization, and definitive boundaries to theoretical computer science for nearly 30 years has been challenged not by a human savant, but by a reasoning model operating across continuous chains of formal logic. Whether the proof survives the uncompromising gauntlet of peer review or reveals a subtle, fascinating flaw, the frontier of computation has irrevocably shifted. The boundaries of what can be calculated, what can be known, and who—or what—makes scientific discoveries have officially been redrawn.