How Terence Tao Used ChatGPT to Stress-Test a Jacobian Conjecture Counterexample

The Session: What Actually Happened

On an otherwise ordinary day, Terence Tao—arguably the world’s greatest living mathematician—logged into ChatGPT and started a conversation that ricocheted through technical circles. He wasn't asking for a recipe or a boilerplate email. He was probing a specific, high-stakes mathematical object: a potential counterexample to the Jacobian Conjecture.

The Jacobian Conjecture is a notorious open problem in algebraic geometry. In plain terms, it asks whether a polynomial map with a constant non-zero Jacobian determinant must have a polynomial inverse. It sounds niche, but it sits at the intersection of deep theory and computational algebra. A valid counterexample would be a seismic event in pure mathematics.

Tao had encountered a candidate polynomial map that seemed to break the conjecture. Instead of spending weeks grinding through algebraic manipulations by hand, he used ChatGPT as a collaborative reasoning engine. His approach, visible in the shared transcript, was surgical.

He didn't ask the model to "prove the Jacobian Conjecture is false." He fed it the specific polynomial system and asked targeted questions: "Is this map injective?" "Compute the Jacobian determinant." "Find a point where injectivity might fail." The model ran symbolic manipulations, generated algebraic insights, and even wrote small snippets of code to check properties numerically. Tao cross-examined the output, spotted a subtle algebraic error the model made, corrected it, and steered the investigation. The result wasn't a definitive proof, but a high-speed, iterative narrowing of the problem space. He used the AI to eliminate dead ends and generate candidate lines of attack faster than any human assistant could.

This wasn't passive consumption. It was a dialogue between a domain expert and a pattern-matching engine, where the expert held the map and the compass.

The Engineer's Take: Why This Changes Your Workflow

For working engineers, Tao's session is a template for a new kind of development loop. The core pattern is speculative execution with an expert in the loop. You propose a hypothesis, ask the model to execute the tedious verification steps, inspect the output critically, and use the results to form the next hypothesis.

Here’s the breakdown of what he actually did, translated to engineering terms:

1. Define the Object Under Test: Tao provided the exact polynomial system. In engineering, this is your function, your API contract, your database schema, or your infrastructure-as-code definition. The precision matters. Vague prompts yield vague results.
2. Generate Property Checks: He asked for specific, measurable properties: injectivity, Jacobian determinant, potential failure points. This is the equivalent of asking an AI to generate unit tests, fuzzing inputs, or write a static analysis script against your code. You're offloading the grunt work of "what could break here?"
3. Cross-Examine the Output: The model made a mistake in an algebraic simplification. Tao caught it because he knew the domain. This is the critical step. The model is a junior developer with encyclopedic knowledge and no judgment. You are the senior architect reviewing the pull request. You don't merge without understanding.
4. Iterate on the Hypothesis: Based on the model's output, Tao would ask a new, sharper question. This is the scientific method at machine speed.

This workflow directly parallels how you should use AI for complex debugging or system design. Instead of asking, "Why is my system slow?", you ask, "Given this specific query plan from PostgreSQL, hypothesize three reasons for a performance regression after the last index change, and suggest a diagnostic query to confirm each." You're constructing a tight feedback loop where the AI is a force multiplier for your own expertise.

The FDE Lens: Shipping Math-Grade Rigor in the Enterprise

Forward Deployed Engineers (FDEs) operate in the most chaotic, high-stakes environments. You're inside a customer's infrastructure, and a wrong answer doesn't just mean a failed test; it means a broken production pipeline or a loss of trust. The Tao method isn't a luxury here—it's a survival skill.

Consider a classic FDE nightmare: you're deploying an LLM feature that must query a customer's messy, undocumented Postgres database and return accurate answers. A hallucination is a business error. The naive approach is to wire up a text-to-SQL tool and pray. The Tao approach is to treat the database like his polynomial system.

• Define the System: You don't just give the AI the schema. You provide a formal description of the business logic embedded in the tables, the known data quirks, and the invariants that must hold.
• Generate Property Checks: You ask the AI to generate a battery of SQL queries that test the boundaries of the business logic. "For every order, there must be a corresponding payment." "Write a query to find any violation of this invariant." You're not asking for the feature code yet; you're asking it to generate the test harness first.
• Cross-Examine: You run those queries. Do the results make sense? Is the AI's interpretation of a "payment" correct, or did it miss the edge case of refunds? You correct its understanding, just as Tao corrected the algebra.
• Iterate: Only after the system's logic is rigorously probed do you generate the final SQL analyst agent.

This is the essence of building trust with a customer. You don't demo a magic trick. You demo a rigorous process. You show them the generated test suite that proves the feature works on their dirty, real-world data. This is how you go from a vendor to a trusted partner. For a deep dive into building such an agent with this level of rigor, see our guide on how to Deploy a Natural Language SQL Analyst Agent Over Your Postgres DB with Supabase and Gemini.

The same pattern applies to any complex integration. When building an agent that negotiates meeting times over email, you don't just trust it to parse dates. You define the formal state machine of a calendar negotiation, ask the AI to generate emails that would violate the state machine, and see if your agent handles them gracefully. This is the difference between a demo and a deployment, a topic we explore in our Calendar-Scheduling Agent build.

How to Replicate Tao's Method Today

You don't need a Fields Medal to start. You need a problem, a precise definition, and the discipline to not trust the machine. Here is a practical, step-by-step guide to running your own Tao-style exploration.

Step 1: Isolate and Formalize the Problem

Don't paste a 500-line stack trace. Extract the core logic block in question. Write a formal specification of what it should do. This can be a function signature with strict type hints, a JSON schema, or a set of mathematical constraints.

Bad: "My user auth is broken, help." Good: "Here is a Python function validate_session(token: str, db: Connection) -> Optional[User]. The token is a JWT with claims {'user_id': int, 'exp': int}. The function must return None if the token is expired or the user is marked as inactive in the database. It must raise InvalidTokenError if the signature is invalid. Find a logical flaw where an expired token for an inactive user could return a User object."

Step 2: Demand Specific, Verifiable Outputs

Force the model to generate artifacts you can independently verify. Don't let it opine.

• Generate Counterexamples: "Given this function, generate 5 input tuples (token, db_state) that you predict will cause an incorrect output."
• Generate Tests: "Write a pytest test suite that tests the edge cases you identified."
• Generate Formal Models: "Translate this function's logic into a TLA+ specification so we can check invariants."

Step 3: Be the World's Most Annoying Code Reviewer

Execute every piece of code it generates in a sandbox. Scrutinize every logical step. The model will confidently assert a falsehood. Your job is to catch it. When you find an error, do not just say "wrong." Explain why it's wrong, providing the counter-counterexample. This teaches the model's context window and refines its subsequent outputs. This is the "expert in the loop" principle in action.

Step 4: Chain the Insights

Once the model correctly identifies a flaw, use that as a springboard. "Given that this edge case exists, what other functions in this module might share the same faulty assumption? Generate a list and a one-sentence rationale for each." You're not just fixing a bug; you're using the AI to perform a blast-radius analysis.

This method is a core skill for the modern engineer. It's the exact opposite of vibe coding. It's precision engineering with an AI co-pilot. If you're preparing for a role that demands this level of execution, like an FDE position, the interview process will test your ability to think this way, not your ability to invert a binary tree. We've broken down how to prepare for that reality in our guide on The FDE Interview Loop: How to Prepare for Execution, Not LeetCode Crimes.

The Balanced View: Limitations and Guardrails

Tao's session was a success because he never ceded authority to the model. This is the single point of failure for most AI-augmented workflows. The model is a simulator, not an oracle. Its greatest danger is its eloquence. A confident, well-structured, and completely wrong explanation can slip past a tired engineer's defenses.

The limitations are sharp:

• No Ground Truth: The model has no intrinsic understanding of truth. It's predicting tokens. In Tao's case, it performed an algebraic simplification incorrectly because that specific pattern was likely underrepresented in its training data. For an engineer, this means the model will be dangerously bad at your company's unique, proprietary legacy code.
• Context Decay: Long conversations suffer from the model forgetting or misweighting constraints set early on. Tao's session was effective because it was a series of short, sharp, self-contained probes. A multi-hour, rambling debugging session is a recipe for confusion.
• The Verification Burden: The method only works if you are capable of verifying the output. This means you must be a domain expert. An AI can't help a junior developer safely refactor a distributed consensus algorithm. The tool amplifies the user's capability; it doesn't replace it. The skill floor for using AI effectively is actually quite high.

The guardrail is simple and Tao demonstrated it perfectly: Trust the process, not the output. The value is in the exploration, the generated test cases, and the alternative viewpoints—not in the final "answer." If you can't independently verify a claim the model makes, you treat it as a hypothesis to be tested, not a conclusion to be shipped.

FAQ

What is the Jacobian Conjecture in one sentence? It's a conjecture stating that if a polynomial map has a constant, non-zero Jacobian determinant, it must have a polynomial inverse, making it a one-to-one mapping.

Did Terence Tao actually solve the Jacobian Conjecture with ChatGPT? No. He used ChatGPT to explore a potential counterexample. The session was a sophisticated process of elimination and hypothesis generation, not a final proof.

What's the single biggest takeaway for an engineer? The workflow of using AI to generate specific, verifiable property checks (tests, counterexamples, formal specs) and then critically reviewing them is the highest-leverage way to use these tools for complex work.

Can I use this method if I'm not a domain expert? Effectively, no. The method's safety and value rely entirely on your ability to verify the AI's output. Without deep domain knowledge, you're just reading plausible-sounding text. For learning, it's a great tool, but for production work, expert oversight is non-negotiable.

How does this relate to Forward Deployed Engineering? It's the core loop. FDEs constantly probe unfamiliar, messy customer systems under high trust requirements. The Tao method of formalizing, generating checks, and cross-examining is how you ship rigorous solutions fast without breaking things.