AI Explores. Evidence Earns Trust.

Some problems become much harder as the number of choices grows. With a series of yes-or-no decisions, each extra decision doubles the number of possible combinations. OpenAI reports that an AI system has found a new way to count which combinations obey a set of rules, with a better theoretical growth rate than a longstanding mathematical hypothesis would allow. That could change our understanding of what computers can do. It does not yet tell us that an everyday task will run faster. [1–3]

The wider question is how AI might help us discover new methods, rather than only apply methods we already know. A promising discovery still needs people to understand it, check what it proves and test whether it can become a useful tool. This article follows that journey, starting with a small example before moving to the mathematics and possible applications.

Choose your level of detail: start with the yes-or-no example, see what applications would still require, or read the exact bounds in the technical appendix.

A scientific collaborator needs a verification process

On 26 October 2026, OpenAI announced an AI-produced refutation of the Exponential Time Hypothesis, or ETH. This hypothesis concerns how quickly the work needed to solve a particular kind of logical problem grows as the problem gets larger. OpenAI also said that the result had been formalized in Lean, a system for checking mathematical proofs. [1]

The announcement named Russell Impagliazzo, Ramamohan Paturi and Ryan Williams as leaders of an independent collaboration to examine and explain the work. In the sources reviewed for this article, that examination had been announced; a completed independent verdict had not been established. We therefore describe a research claim with published supporting material, rather than a settled scientific consensus.

Three questions guide the discussion: What exactly is the problem? What has been checked? What would be needed to use the result? Keeping those questions separate helps us take a potentially important contribution seriously without attributing more to it than the evidence supports.

SAT, counting and the meaning of “fixed k”

Imagine two switches, x and y. Each can be on or off. We impose two rules: at least one switch must be on; and either x must be off or y must be on. Written as logic, the rules are:

(x OR y) AND (NOT x OR y)

There are four possible settings. Two work: x off with y on, and x on with y on. SAT, short for satisfiability, asks whether any setting obeys all the rules. #SAT, pronounced “sharp SAT,” asks how many settings do. Here SAT answers yes and #SAT answers two. This example explains the task; it is not a performance test of the released algorithm.

The mathematical vocabulary gives these simple ideas precise names. A Boolean variable is a yes-or-no choice, such as a switch being on. A literal is a variable or its opposite, such as “x is on” or “x is not on.” A clause is one rule saying that at least one of its listed conditions must hold. The complete formula requires every clause to hold.

In k-SAT, each clause contains at most k literals. The number k limits the length of each rule, not the total number of rules or variables. “For each fixed k” means that we choose that limit and keep it constant while the problem grows. The theorem’s hidden constants can depend on k; letting k grow with the input would require a different analysis. [2, Theorem 1.1]

With n variables there are 2ⁿ possible settings. Checking all of them is a straightforward starting point. ETH says, roughly, that even for rules of length at most three, no algorithm can avoid exponential growth in the worst case. “Worst case” matters: the claim concerns a guarantee across all valid inputs, not how difficult every individual puzzle is. The next section explains the growth rates more precisely.

The manuscript, dated 17 October and revised 25 October 2026, claims an algorithm for exactly counting the solutions of k-SAT formulas, for each fixed k. Its guarantee has four parts: [2, 3]

• Exact: it gives the number of solutions, rather than an estimate.
• Deterministic: the main counting algorithm does not rely on random choices.
• Subexponential time: its worst-case work grows more slowly, in the precise sense below, than an exponential with an exponent proportional to n.
• Polynomial space: its memory bound grows as a fixed power of the input size. That does not, by itself, promise small memory use on a real computer.

Counting also answers the simpler yes-or-no question: a count above zero means a solution exists. That is why this counting result, if established, would refute ETH. It is not a claim that all difficult problems suddenly become easy.

Read the claim at its actual scope

Here is what to carry forward before considering applications.

The P versus NP question asks whether every problem whose proposed solution can be checked in polynomial time can also be solved in polynomial time. NP-hard describes problems at least as hard as those in NP under the relevant polynomial-time translations. These terms concern mathematical relationships between problems; they are not a measurement of how long a particular application will take.

The theorem and its consequences below are reported from the manuscript. The explanations help interpret their scope. The later recommendations about organizing AI research are Flashback’s analysis, not additional conclusions of the theorem. [2–5]

Subexponential is a major distinction, not a runtime promise

An algorithm is a procedure for solving a problem. To compare algorithms, researchers ask how the amount of work grows with the input. A method that looks attractive on a small example may become unusable as the example grows.

Three growth patterns help explain the distinction. These are mathematical illustrations, not measured runtimes:

• Polynomial, such as n³: the input size is raised to a fixed power. Doubling n makes this expression eight times as large.
• Exponential, such as 2ⁿ: n appears in the exponent. Adding just one variable doubles this expression.
• Subexponential, such as 2^√n: the exponent grows more slowly than n. The amount of work can still become enormous; “subexponential” does not mean “small.”

The released result is not a 2^√n algorithm. That is only an easy-to-read example of the category. The actual bounds improve the exponent through logarithmic factors, and their improvement develops more slowly than in this example. The exact expressions are in the technical appendix.

This way of describing growth is called asymptotic analysis: it asks what happens as inputs become arbitrarily large. It does not give a running time in seconds for an input on your desk. The constants hidden by the notation, the work of preparing the input, exact arithmetic and memory use can all matter. A theoretically better method might only overtake an existing one at sizes too large to be useful.

That leaves a concrete engineering question: for which inputs does an implementation beat a relevant existing method, after including conversion and checking costs? A correct theorem and a useful implementation answer different parts of that question.

Compare how the work grows, not seconds on a stopwatch. These examples are not benchmarks or the ETH algorithm’s exact bound.

Why reductions do not transfer the conclusion automatically

To apply a SAT result elsewhere, researchers often translate another problem into SAT. This translation is called a reduction. A solution to the translated problem must give the answer required by the original problem.

There is a catch: the translation can make the problem much larger. Imagine a puzzle with N pieces that must first be rewritten as a SAT instance with N² variables. Even a better method for the rewritten puzzle may offer no subexponential guarantee in terms of the original N pieces. This is an illustration of the size issue, not a proposed application or a performance estimate. The substitution is shown in the appendix.

A translation taking polynomial time can still cause this kind of growth. That is why “we can express the problem as SAT” is not enough to claim the same improvement for it.

The manuscript states this limitation on page 2, immediately before Corollary 1.3. It does not conclude that all general NP problems have subexponential algorithms. Where a translation keeps the relevant size small enough and preserves the answer we need, specific consequences can follow. We must check those details for each problem. [2]

Some earlier arguments about difficulty are conditional: they say that a certain fast algorithm cannot exist if ETH is true. Refuting ETH would remove that particular reason for ruling it out. It would not automatically provide the missing algorithm. Removing a barrier in an argument and building a working method are separate achievements.

The size after translation matters. Count the new variables, then express the guarantee in the original problem’s size.

What the manuscript actually transfers

The paper does identify specific consequences, called corollaries. To read the examples below, picture a graph as a set of dots joined by lines. The dots are vertices and the lines are edges. We write v for the number of vertices and e for the number of edges. The notation 2^o(v) means a subexponential growth rate in v. [2, Corollaries 1.2–1.3]

Independent sets: choose dots with no line between them. An independent set is a selection of vertices with no adjacent pair. One yes-or-no variable can represent whether each vertex is selected; a clause forbids selecting both ends of an edge. This translation preserves the number of solutions. The paper reports exact counting of independent sets in 2^o(v) time.

Graph colourings: give connected dots different colours. A proper colouring assigns a colour to every vertex, with different colours at the ends of each edge. For a fixed number q of colours, the paper uses qv Boolean variables and preserves the number of valid colourings. It reports exact counting in 2^o(v) time. The condition that q stays fixed is part of the result.

Perfect matchings: pair up all the dots along existing lines. A perfect matching selects edges so that every vertex belongs to exactly one selected edge. The paper’s counting-preserving circuit encoding uses O(v + e) variables and clauses: its size grows at most proportionally to the combined number of vertices and edges, up to a constant factor. The reported bound is 2^o(v+e), not 2^o(v). This difference matters when a graph has many edges.

Max-k-SAT: satisfy almost as many rules as the best possible setting. Some formulas have no setting that satisfies every clause. Max-k-SAT asks for one satisfying as many as possible. Here the paper reports a randomized approximation algorithm, distinct from its deterministic exact-counting algorithm. For fixed k and fixed ε > 0, it returns a setting satisfying at least OPT(F) − εm clauses, with probability 1 − 2^−Ω(n). OPT(F) is the best achievable number, m is the number of clauses, and ε is a chosen error allowance. In words, the result may fall short of the optimum by at most ε times the total number of clauses; the failure probability shrinks exponentially with n. The runtime constants depend on k and ε.

These are precise theoretical consequences, not benchmarks. Each keeps together the task, the quantity that measures its size and the kind of answer guaranteed. Those details determine whether a later application can use it.

A proof artifact, an explanation and a consensus do different jobs

A useful way to read the release is to distinguish three forms of evidence.

The manuscript explains the mathematical argument. It uses ordinary notation and prose. Mathematicians call this an informal proof to distinguish it from a proof encoded in a formal system; “informal” does not mean careless. OpenAI attributes this manuscript to its AI work, so it should not be described as a human-authored proof. [1, 6]

The formal proof expresses a statement in rules a checker can follow. Lean checks mathematical steps against explicit definitions and logical foundations. That is stronger evidence than an explanation merely sounding convincing. The exact statement still matters. A checker verifies the statement written down; people must also establish that its definitions, inputs and measures of time and memory match the claim they intend to make.

For example, the published Lean scope describes how the inputs are encoded, how many computation steps are allowed and how much memory may be visited. Its time bound is slightly weaker than the sharper bound in the revised manuscript: it has an extra log log n factor in the exponent. Both are subexponential for fixed k. The distinction is written out in the appendix; the stronger manuscript bound must not be attributed to Lean’s documented scope. [2, 3]

Independent examination checks meaning and implications as well as the argument. Researchers can reconstruct the ideas, inspect dependencies, assess novelty and test whether claimed consequences follow. Agreement about a formal statement does not automatically settle every interpretation or application. The independent collaboration announced by OpenAI is therefore a separate part of the scientific process.

For this article, the selected Lean endpoint—the final statement and proof—and the configuration used to compare it with the challenge were read. Their imported dependencies were not compiled or independently certified. This editorial review is not a proof audit. Similarly, Anthropic’s separate formal-math/eth development must be assessed on its own statement and files. Work on the same topic is not, by itself, an independent verification of OpenAI’s proof. [4, 5]

The manuscript, proof checker and independent researchers contribute different evidence. Practical performance still needs testing.

How the mathematical approach can be explained

The counting problem appears to invite checking every possible setting of the switches. At a high level, the paper instead rewrites the count as an algebraic expression, then organizes the computation so it does not have to evaluate that expression separately for every setting. [2, §§2–6 and Appendix D]

First, the clauses become polynomials—algebraic expressions whose values encode whether their rules are met. Combining them gives a sum of products representing the exact count. This change of notation alone saves nothing: evaluating it for every assignment would still be exhaustive search.

The construction then introduces a parameter, which can be thought of as an extra dial in the expression. At one designated dial setting, the expression gives the count we want. At other carefully chosen settings, groups of variables can be handled through controlled amounts of shared linear information. Fixing that shared information allows more local calculations. Interpolation, a way of recovering a polynomial from enough of its values, is then used to recover the desired count.

The difficult part is proving that all those intermediate calculations, including the shared information and the recovery step, stay within the claimed time and space bounds. The paper does not assume that any SAT problem naturally falls into independent pieces. Appendix D uses Boolean tensor-network contraction, a way of organizing sums and products of interconnected arrays, for the sharper runtime.

This is a guide to the idea, not a substitute proof. In particular, “tensor” does not mean quantum computing: the manuscript describes a deterministic classical algorithm and measures bit operations, elementary operations on binary data.

For AI collaboration, the point is the work between proposing a construction and making it understandable to others. A formal statement, an explanation and eventually an implementation are different outputs. Each must connect correctly to the next.

Cryptography: a bounded consequence

Cryptography provides a useful test of that discipline. A function maps an input to an output. Inverting it means finding an input that could have produced a given output. A candidate one-way function is designed to be easy to compute but difficult to invert within the relevant security definition.

Appendix C.2 concerns a particular family of functions on binary data: each output bit depends on at most a fixed number d of input bits. This is called constant locality. The sets of input bits may overlap, so the outputs need not be independent. [2, Appendix C.2]

For these functions, requiring an input to produce a chosen output can be written as a bounded-width SAT formula on the original input variables. When the number of output bits is polynomial in the input size, the paper obtains a claimed subexponential inversion algorithm. This includes constant-locality versions of Goldreich’s candidate one-way functions.

The paper explicitly says that this does not exclude security against polynomial-time algorithms. A subexponential attack can still fall outside that faster class. A theoretical improvement in attack time is therefore not the same statement as a practical break.

The result demonstrates no RSA or AES break and establishes no new cryptographic migration deadline. Applying it to a deployed scheme would require a scheme-specific translation, concrete time and memory estimates, and security analysis. Those steps have not been established here.

Proteins, fusion and machine learning: define the missing bridge

The prospect of better algorithms naturally raises questions about other difficult tasks. The connection has to be built for the specific task; sharing the label “hard” is not enough.

Protein folding. Berger and Leighton’s 1998 result concerns a simplified model in which a chain occupies positions on a three-dimensional grid and its units fall into two types: hydrophobic or hydrophilic, abbreviated HP. The result establishes NP-completeness for a problem in that model. It does not describe the full biophysical folding process. [7]

To turn the ETH claim into a useful result here, researchers would first need to identify exactly which folding question they want to answer. They would then need a suitable translation, an account of how much it enlarges the input, and evidence that the answer remains biologically meaningful. Faster computation for a simplified model would not, on its own, validate a biological prediction or a medical conclusion. Experimental validation would still be necessary.

Fusion. AI has also been used to control plasma configurations on the TCV tokamak, a magnetic-confinement fusion experiment. Degrave and colleagues reported this work in Nature on 16 February 2022. Their method used reinforcement learning, in which a system learns control actions from feedback. This was a specific experimental control result, separate from the ETH manuscript. [8, 10, 11]

It illustrates a different route from an AI method to a bounded scientific experiment. It does not show that the SAT-counting result solves plasma control or makes commercial fusion imminent. Any proposed connection to the ETH algorithm would need its own mathematical translation, engineering work and experimental tests.

Machine learning. Training a model, running it to produce answers, choosing data and searching for a model architecture are different tasks. Complexity results apply to particular formulations: the objective being optimized, the allowed architecture, the precision required and the way inputs are represented. A result about one such formulation cannot be applied to all model training.

An ETH-related improvement would need to be shown for a specified machine-learning task, then implemented and compared with existing methods. The release does not demonstrate faster training of large language models.

These examples identify research questions. They do not justify a promise of usable applications within a few months. The useful next step is to name the missing test, rather than assign a delivery date to a theoretical possibility.

From discovery to governed integration

For a team considering whether to use a research result, the journey can be divided into six stages. This is a framework proposed by Flashback for this article, not a report of a completed ETH deployment. Governed integration means putting a method into use with a responsible owner, clear permissions, monitoring and a way to reverse a change.

Progress can go backwards. An implementation may reveal a misunderstood assumption. A reviewer may narrow a claimed consequence. A benchmark—a comparison on defined test inputs—may show no useful advantage at realistic sizes. A correct theorem does not eliminate these decisions.

For ETH, published mathematical and formal proof material is available for examination. In the sources reviewed here, independent understanding and practical algorithm development remain open work. A statement about growth rates cannot supply a timetable for the remaining stages.

A proposed research workflow. At each stage, pass on evidence and identify who makes the next decision.

Build a research workflow around collaboration

The same approach can make AI-assisted research easier to assess even before a major theorem is settled. The following is a proposed operating model, not a claim about a completed customer deployment or a measured result.

Start with a question someone can test. State what is being studied and what would count as a useful answer. For an algorithm, distinguish deciding whether a solution exists, finding one, counting all of them and finding an approximate answer. They are different commitments.

Give the AI a defined research role. It might draft an argument, look for a counterexample, translate notation, suggest an implementation or organize related work. Require it to retain its sources and uncertainty. Permission to propose an experiment should not also authorize spending money or changing an operational system.

Choose a check that fits the output. A formal theorem needs proof checking. Code needs tests and a reproducible build. A predictive system needs evaluation on data kept separate from training. A claim about the physical world needs experiments. A second model giving a persuasive answer is not automatically independent evidence.

Ask an expert to examine the interpretation. Does the formal statement answer the original question? Are its assumptions acceptable? Does a proposed application preserve the right size measure and kind of answer? A reviewer must have enough context and time to reject an unsupported conclusion.

Leave a record another person can use. Keep the source version, theorem or experiment identifier, dependencies, checking instructions, result and unresolved objections. Record what was actually approved and for which use. A result awaiting review should remain distinguishable from one approved for a particular experiment.

Measure the whole process. Compare with a relevant existing method on defined workloads. Include input conversion, computation, memory, review, failed attempts and rework. Producing candidates faster may not save time overall if checking them becomes the slowest step.

Expand permissions only when the evidence supports it. Give an agent more responsibility when its observed behaviour and recovery arrangements justify that change. Keep a human owner for decisions whose consequences reach beyond the experiment.

In this model, the AI contributes ideas and work that can change the direction of inquiry. People retain responsibility for the standards of evidence, the interpretation and the decisions that follow.

What enterprise teams can change now

A team can improve that process without assuming that the ETH claim has reached consensus.

Consider a platform team evaluating a proposed optimization method. Before running it, the team could record the algorithm, its assumptions, the expected benefit, the allowed computing budget and the test that would support or reject it. A reviewer would authorize a limited experiment in an isolated environment. Only measured results, including failures, could support a later proposal for operational use. This is an illustrative workflow, not a Flashback product feature or a claim that this ETH method is ready to use.

The practical requirements are concrete: save versions of the inputs, make the experiment repeatable, restrict credentials, set resource budgets and retain logs. Decide who can approve the experiment, what result would justify continuing, and who can stop or reverse a change.

Failure also needs an honest explanation. It may come from an unsuitable task, model limitations, an unclear objective, missing information, integration defects or a poor evaluation method. It cannot automatically be blamed on the user. A scientific objection likewise deserves examination on its merits; caution about a particular claim is not hostility to AI.

“Quantum transformation” is an organizational frame here

Brieuc uses “quantum transformation” to describe a substantial redesign of how people and AI work together: how they divide tasks, check results and authorize decisions. Here it is a management metaphor. It makes no claim about quantum hardware, quantum algorithms or a quantum speedup.

The useful question is what changes in the work itself. Counting how many people use a chatbot tells us little about whether their decisions are better supported or whether reviewing the output is manageable. Those outcomes require expertise, clear ownership and learning from failed attempts.

Flashback is an Agentic Transformation Company. Agentic Transformation redesigns enterprise workflows around bounded agent actions and retained human authority. Applied to research, this means deciding where an AI may explore, what evidence must accompany its output and which conclusions require an accountable human decision. It does not mean that Flashback has validated this theorem or provides a certified scientific-proof service. [9]

Turn optimism into a testable next step

The ETH release offers a concrete example of what AI collaboration asks of us. A system may contribute a difficult mathematical construction. Other people must be able to understand its scope, inspect the evidence and determine whether a useful method follows.

Read the precise claim, keep the manuscript and formalized bounds distinct, follow independent examination and test applications one problem at a time. That process leaves room for an important result and for corrections to its interpretation.

For an organization, a useful first step is to choose one research or engineering workflow and decide what evidence an AI contribution must carry before someone relies on it. Book a call with Flashback to discuss that workflow’s scope, evidence requirements and human decisions. The invitation is to define the work; it is not a promise that this ETH result is ready for deployment.

Technical appendix

The main text gives the meaning of the result. This section preserves the exact guarantees and the limits of the source check for readers who want to inspect them.

A. Three bounds that must remain distinct

Let n denote the declared Boolean variable count, m the number of input clauses, and k a fixed clause-width bound. The manuscript states its theorem for n ≥ 20. The notation O describes an upper bound up to constant factors; subscripts indicate which fixed parameters those constants may depend on. A polynomial factor has a fixed exponent. The notation o(n) denotes a quantity whose ratio to n tends to zero. Logs in the manuscript are natural logarithms. [2]

• Revised manuscript, general inputs (Theorem 1.1):

(n + m)^{O_k(1)} · 2^{O_k(n log log n / sqrt(log n))} bit operations, with (n + m)^{O_k(1)} bits of space.

• Revised manuscript, fixed clause density m ≤ Dn, for fixed D > 0:

(n + m)^{O_{k,D}(1)} · 2^{O_{k,D}(n / sqrt(log n))}, with polynomial space.

• Documented Lean scope, canonical encoding of bit length L:

(L + 1)^{O_k(1)} · 2^{O_k(n (log log n)^2 / sqrt(log n))}, with at most (L + 1)^{O_k(1)} visited tape cells at every execution prefix. [3]

The scope description gives the asymptotic form above. The extra log log n in the exponent must not be erased when comparing the formalized scope with the sharper manuscript result.

For any fixed c, (log log n)^c / sqrt(log n) tends to zero. Hence these exponential terms are of the form 2^o(n). This does not remove the input-size polynomial or turn the stated guarantee into polynomial time. In particular, the input must still be read; arbitrary repetitions of clauses should not disappear from a full runtime statement.

The size-translation example from the main text can now be made precise. If an original input of size N becomes a SAT instance with n = N² variables, substituting into the manuscript exponent gives a term of order N² log log N / sqrt(log N). That is not o(N). A subexponential guarantee in n therefore does not establish one in the original N. This illustrates why a polynomial-time reduction alone is insufficient. [2, p. 2]

B. Recovering a witness and preserving counts

A witness here means one concrete setting that satisfies every clause. If an exact count is positive, such a setting can be recovered by fixing variables one by one and retaining a branch with positive count. This introduces polynomial overhead. Sampling branches in proportion to their conditional counts also gives a uniform satisfying assignment with the expected-overhead qualification described in the paper. [2, p. 2]

A translation that preserves whether a solution exists does not necessarily preserve how many solutions exist: a decision reduction is not automatically a counting reduction. Auxiliary variables can multiply the number of solutions. The graph corollaries use encodings that preserve the count; for perfect matchings, the circuit gate variables are uniquely determined once the edge-selection bits are fixed. This is why the reduction’s semantics matter as well as its size.

For Max-k-SAT, define rho(n) = n(log log n)^2 / sqrt(log n). Corollary 1.2 states runtime (n + m)^{O_{k,epsilon}(1)} · 2^{O_{k,epsilon}(rho(n))} and polynomial space. Its guarantee is additive error εm with exponentially small failure probability for fixed k and ε. It must not be rewritten as an unconditional multiplicative approximation ratio. [2]

C. What was checked in the formal artifacts

The reviewed endpoint is exact_count_and_sat in SqrtLogSpace, under the OAI.Algorithms.SubexponentialSAT namespace. The catalogue maps it to OAI/Algorithms/SubexponentialSAT/SqrtLogSpace/Final.lean. The comparator configuration points to the Main module under that same namespace and lists propext, Quot.sound and Classical.choice as permitted axioms; enable_nanoda is false. These are configuration observations, not a reproduced verification result. [4, 5]

The comparator challenge file contains the target statement with sorry. That file must not be confused with the solution proof: the separately inspected endpoint contains proof terms and imports supporting modules. Seeing the challenge placeholder neither validates nor invalidates the supplied solution. Checking the actual solution, dependencies and admitted axioms requires running the documented procedure in a suitable environment.

This editorial review did not perform that build, audit the complete dependency closure, reproduce an independent checker run, or certify the correspondence of every manuscript corollary to a formal theorem.

D. Questions for the next scientific review

• Does an independent run verify the published endpoint with only the stated permitted axioms, at a pinned repository commit?

• Which sharper bounds and corollaries have their own formal certificates, rather than only an informal derivation?

• Have the independent researchers published an assessment, correction or revised scope since the announcement?

• What explicit constants, fallback thresholds and implementation costs determine the first meaningful benchmarks?

• For each proposed application, what is the reduction, how large is the encoded instance, and does it preserve counting, optimization or approximation as required?

• Are reported gains robust when preprocessing, conversion, memory, verification and failed instances are included?

The answers determine how the article should evolve. None should be supplied by inference from the announcement alone.

Sources and reading scope

Sources reviewed on 27 October 2026. Research claims are attributed to their authors. Mathematical interpretation and workflow recommendations are distinguished from empirical outcomes. No Lean build, complete proof audit, independent community verdict or practical ETH benchmark was produced for this article.

1. OpenAI, 26 October 2026. Working with academic communities to build scientific understanding. Announcement of the claim and independent examination; no completed independent verdict is established by this source.

2. OpenAI, dated 17 October; revised 25 October 2026. The Exponential Time Hypothesis is False. Theorem 1.1, Corollaries 1.2–1.3, page 2 reduction caveat, technique overview and Appendix C.2. The 67-page PDF was extracted locally; page 2 was visually checked. This is a scoped editorial check, not a full proof audit.

3. OpenAI. Lean formalization scope, family 378. Canonical input, the squared log-log factor and polynomial visited-space scope.

4. OpenAI. SubexponentialSAT comparator configuration. Solution-module mapping and permitted axioms read; the checker was not executed.

5. OpenAI. SubexponentialSAT solution endpoint. Selected endpoint read; imports not recursively audited or compiled. The comparator challenge is a separate target statement.

6. OpenAI. Mathematical manuscripts repository. Release provenance; not independent scientific confirmation.

7. Berger and Leighton, 1998. Protein folding in the hydrophobic-hydrophilic (HP) model is NP-complete. Journal of Computational Biology 5(1), 27–40. Simplified 3D cubic-lattice HP problem; not general biophysical folding. The original abstract, retrieved through Europe PMC, confirms the 3D scope; full publisher text was inaccessible in this review.

8. Degrave et al., 16 February 2022. Magnetic control of tokamak plasmas through deep reinforcement learning. Nature 602, 414–419. Bounded TCV control result, corroborated by the authors’ conference abstract and DeepMind’s research account; Nature full text was inaccessible here.

9. Flashback. Agentic Transformation. Company framing uses canonical PROD-001, MSG-036/037 and CLM-022/023. It is not evidence for the theorem or a scientific-proof service.

10. Felici et al., 2022. Magnetic Control of the TCV tokamak through Deep Reinforcement Learning. Author conference abstract supporting the narrowly stated TCV experiment.

11. Google DeepMind, 16 February 2022; text updated after May 2024. Accelerating fusion science through learned plasma control. First-party research account, used for context rather than a new ETH consequence.