From Open Conjectures to Formal Verification: Lessons from AI’s Role in Complex Theory Research

In recent years, artificial intelligence has improved rapidly in code generation, mathematical reasoning, and scientific research. In formal mathematical environments in particular, models no longer need only to produce natural-language proofs that “look reasonable.” They must generate rigorous proof terms that a proof assistant can check step by step. An important consequence is that AI is beginning to move from “explaining existing knowledge” toward “searching for unknown conclusions.”

Recent reports suggest that a research team used an unreleased AI model to solve a long-standing conjecture in theoretical computer science in a short period and verified it through a formal proof environment. Because the relevant details, full proof text, and experimental process have not been fully disclosed, the more prudent statement is this: the event demonstrates the potential of AI-assisted mathematical research, but the final conclusion still requires independent replication, public material review, and peer review.

1. What Is the Core Problem in This Type of Conjecture Research?

The conjecture sits at the intersection of computational complexity, probabilistic computation, and quantum computing. It is not concerned with the running speed of a specific machine. Rather, it concerns whether different computational models have provable differences in capability when handling certain types of problems.

In plain terms, researchers want to answer questions such as:

• Can classical algorithms efficiently simulate certain computational tasks that appear random or structurally constrained?
• If classical algorithms cannot complete such simulations within reasonable resources, can this difficulty be proven through rigorous complexity theory?
• Does quantum advantage come from general exponential speedup, or does it hold only under specific problem structures?
• Can a computational process that is experimentally faster be translated into a strict separation between complexity classes?

These questions are difficult because there is a large gap between “no efficient algorithm has been found yet” and “it can be proven that no efficient algorithm exists.” The former is an algorithm engineering problem. The latter requires a mathematical argument that covers all possible algorithms.

2. Why Can a Conjecture Remain Open for More Than a Decade?

Long-standing conjectures in theoretical computer science often share several characteristics.

First, the problem statement is often concise, but the proof must handle probability, algebra, combinatorial structure, and computational complexity at the same time. A short definition may contain many boundary conditions: how input size grows, how error is bounded, which resources an algorithm may use, and what “efficient” specifically means.

Second, classical methods often produce only partial results. Researchers may prove that a certain class of algorithms cannot solve the problem, or that a result holds within a specific parameter range, but this is not equivalent to ruling out all algorithms. Complexity theory places particular emphasis on the scope of a proof. Any omitted class of algorithms could become a counterexample.

Third, many conjectures require tools from multiple fields. A proof may involve polynomial approximation, Fourier analysis, stochastic processes, graph structure, complexity lower bounds, and quantum state representations. It is difficult for a single researcher to be familiar with all of these tools at once, which is one reason AI-assisted research has attracted attention.

3. What Work Can AI Perform in the Proof Process?

It is important to be clear that AI-assisted proof does not mean the model simply “thinks up the answer” from nothing. A more accurate understanding is that the model participates in search, organization, and verification across multiple stages.

3.1 Translate Natural-Language Goals into Formal Objects

Researchers usually describe a conjecture in natural language first, then convert it into definitions, lemmas, and propositions to be proved. AI can help complete symbolic expressions, unify variable naming, identify implicit conditions, and split a complex goal into smaller subgoals.

The value of this stage is that it lowers the barrier to formalization. But automatic conversion does not mean absolute correctness. Any missing quantifier, incorrect set range, or inappropriate premise can change the meaning of the original proposition.

3.2 Search for Possible Proof Paths

Facing a large goal, a model can try multiple strategies, for example:

• Prove several basic properties first;
• Look for combinations among existing theorems;
• Guess intermediate lemmas that need to be added;
• Adjust the order of the proof;
• Backtrack and switch paths after failure.

This process is closer to “constrained search” than to simple text continuation. Every step generated by the model must satisfy the syntax and logical requirements of the formal environment.

3.3 Generate Auxiliary Code or Proof Scripts

Formal proofs often contain a large amount of mechanical content, such as unfolding definitions, handling boundary cases, constructing mappings, and performing algebraic transformations. AI can reduce repetitive work and let researchers focus on key ideas.

However, the fact that a proof script passes checking only shows that the script complies with the rules of the current formal system. It does not automatically prove that the real problem the researcher intended to express has been modeled accurately. Therefore, “the code passes verification” and “the original conjecture has been correctly solved” remain two layers that must be confirmed separately.

3.4 Help Find Counterexamples and Hidden Assumptions

Before a proof is completed, a model can also be used to test how a conjecture behaves on small-scale instances. If a counterexample appears, researchers can revise the proposition in time. If multiple experiments support the conjecture, they can help identify a more suitable direction for the proof.

It is important to note that finite-scale validation cannot replace a general proof. A proposition holding on many small inputs does not rule out a counterexample at a larger scale.

4. Why Formal Verification Matters

Natural-language proofs are prone to omissions, ambiguity, and unexplained claims that something is “obviously true.” The core value of formal verification is that it breaks a proof into logical objects that a machine can check step by step.

A relatively complete verification workflow usually includes:

1. Clearly define the objects, inputs, and resource boundaries in the problem;
2. Split the main proposition into several manageable lemmas;
3. Create a formal statement for each lemma;
4. Use a proof assistant to check the reasoning steps;
5. Record the axioms, base libraries, and automation strategies the proof depends on;
6. Have independent people rebuild and check the entire proof project.

The last step is especially critical. If a proof can run only in an undisclosed environment, or if it relies heavily on automation that cannot be explained, external review becomes significantly harder. High-confidence results usually require public definitions, complete proof files, dependency versions, build methods, and key intermediate conclusions.

5. How to Assess the Credibility of “AI Solved a Conjecture”

When faced with claims such as “a problem that remained open for years was solved in a few days,” readers can review them from the following angles.

5.1 Was the Precise Proposition Made Public?

It is necessary to confirm whether what was solved is the original conjecture, an equivalent variant, a weakened version, or a result under some special parameter range. The word “solved” in a headline may correspond to conclusions of very different strength.

5.2 Was the Complete Proof Made Public?

An abstract, demonstration video, or partial code cannot replace a complete proof. At minimum, it should be possible to check all dependencies from the definitions to the final conclusion.

5.3 Was There Independent Reproduction?

If only the proposing party reports success, the conclusion should be treated as pending verification for now. Credibility increases significantly only when independent teams can reproduce the result in different environments.

5.4 What Did the Formal System Actually Verify?

It is necessary to distinguish three cases:

• The entire mathematical proposition was verified;
• Only a key lemma was verified;
• Only part of the derivation generated by the model was verified.

The significance of these three cases is completely different.

5.5 Was AI’s Actual Contribution Clearly Stated?

AI may have been responsible for proposing the core idea, or it may have been responsible only for formal encoding. It may have found the proof independently, or it may have performed local search after researchers provided direction. An accurate description of the contribution helps avoid exaggerating model capabilities.

6. What It Means for Quantum Computing Research

If the relevant result is eventually independently confirmed, its significance would not be limited to “AI solved a difficult problem.” It could also affect how people understand quantum computational advantage.

First, it could help researchers distinguish more clearly between theoretical advantage and engineering advantage. A theoretical complexity separation shows that a class of tasks has a difference that is hard to close at asymptotic scale. Engineering advantage must also consider hardware noise, data loading, error-correction overhead, and actual input size.

Second, formal proofs can help build more reliable quantum algorithm theory. The advantage of many quantum algorithms depends on precise probability bounds and complexity assumptions. Formal treatment can reduce hidden gaps in derivations.

Third, if AI can discover new complexity relationships, researchers may gain more exploration tools. However, conjectures generated by a model still need to be tested by the mathematical community. AI is good at search and combination, but that does not mean it can automatically judge the deeper significance of a conclusion within the entire theoretical system.

7. Engineering Practices for Enterprises and Developers

This type of research also offers lessons for ordinary software engineering.

7.1 Split Complex Goals into Verifiable Subgoals

Whether developing a system or proving a theorem, it is best to avoid handling an oversized black-box task all at once. Clear interfaces, local invariants, and testable modules can reduce overall complexity.

7.2 Keep Generation and Validation Independent

AI can generate code, test cases, or candidate solutions, but the final result should be validated by an independent compiler, test system, static analyzer, or formal checker. A generative model’s self-judgment cannot be treated as the final conclusion.

7.3 Preserve Complete Process Records

For important tasks, teams should save inputs, model outputs, revision history, dependency versions, and validation logs. Only with traceability can a team locate errors and reproduce results.

7.4 Focus on Boundary Conditions

Automatically generated content is most likely to have problems with abnormal inputs, empty sets, overflow, resource limits, and error handling. One value of formal methods is that they force developers to make these usually ignored boundaries explicit.

8. Conclusion: The Real Breakthrough Is Not Just Speed, but Verifiability

AI participation in solving long-standing theoretical problems could indeed become an important turning point in how scientific research is conducted. But judging whether a result is truly historically significant should not depend only on the model name, completion time, or media attention. It should depend more on whether the proposition is accurate, whether the proof is complete, whether the process is reproducible, and whether the conclusion can withstand independent review.

In the future, the more important direction is not to have models output longer proof texts, but to build a complete process that runs from problem formalization and candidate generation to machine checking, independent reproduction, and peer review. Only when AI’s search capability is combined with strict verification mechanisms can complex mathematical conjectures truly move from “the model claims to have solved it” to “the research community confirms it has been solved.”