TL;DR
This Google study documents real cases where Gemini Deep Think helped solve open scientific problems, from disproving mathematical conjectures to finding bugs in cryptographic proofs. From these cases the authors extracted general-purpose techniques for working with AI that apply to any hard problem in a regular chat.
Adversarial Self-Correction is the key finding. A plain "check this argument" request gets a shallow answer. The model only finds deep logical errors when it's forced to check its own check. In one case this exposed a fatal bug in a cryptography paper that human reviewers had missed. The reason: the model is prone to confirmation bias. It looks for why an argument is right, not where it breaks. A three-step protocol flips it into critical hole-hunting mode.
Other techniques: Cross-pollination (look for analogies in other fields), Scaffolding (give a high-level strategy and the model fills in the details), Context de-identification (remove any mention that the problem is "unsolved," or the model may refuse), Problem decomposition (split into subproblems you can check). All of them work in a standard conversation, no code or API needed.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Blueprint of the core techniques
Adversarial Self-Correction (3 requests in one conversation):
REQUEST 1: Analyze [the argument/plan/solution]
REQUEST 2: Check your analysis for hallucinations and shallowness
REQUEST 3: Refine the logic given the weak spots you found
Cross-Pollination (one request):
Find an analogous problem in [another field].
Which techniques/solutions/patterns carry over?
Scaffolding (one request):
Here's a high-level strategy: [steps 1-2-3]
Fill in the technical details for each step
Context De-identification:
Give the problem without the "this is an open question" context
→ The model attacks it more boldly
Problem Decomposition:
Break the problem into subproblems that can be checked independently
Example
⚠️ Where the method shines: Hard analytical tasks that need a deep logic check: business plans, strategies, stress-testing arguments.
Adversarial Self-Correction for business analysis
Task: You're vetting an idea for a new product: online AI courses for middle managers. You want to find the weak spots in the logic that you can't see yourself.
Prompt (3 stages in one chat):
# Stage 1
Here's my business idea: online courses on applying AI for middle
managers in the US. Target audience: department heads aged 30-45
who want to bring AI into their workflows but don't know where to start.
Monetization: paid courses at $199-$399, corporate packages.
Analyze this idea: assess viability, risks, assumptions.
---
[The model gives an initial analysis]
# Stage 2
Now check your analysis:
1. Where might you have fallen into confirmation bias?
2. Which obvious counterarguments did you miss?
3. Which risks did you describe only superficially?
---
[The model finds holes in its own analysis]
# Stage 3
Taking the weak spots you found into account, give a final assessment.
Which 2-3 critical assumptions could kill the idea?
Result: After the first request, the model gives an upbeat analysis with generic risks ("competition," "finding an audience"). After the second, it admits it didn't check the essentials: whether the audience is willing to pay that much, whether overloaded managers have the time, whether you as the creator can prove your expertise. In the final round it gets tough: what if managers want to delegate AI adoption down the chain instead of learning it themselves? What if corporations insist on in-person training?
Cross-Pollination for finding solutions
Task: How do you boost retention in a SaaS product for project teams? All the standard tactics (onboarding, email drips) have already been tried.
Prompt:
I have a SaaS for project management in small teams (5-15 people).
Problem: customers churn after 2-3 months.
Find analogous retention patterns in industries OUTSIDE SaaS.
Look at retail, education, fitness, media subscriptions.
Which mechanics carry over to my context?
Result: The model brings in patterns from other fields: gyms retain members through social groups (carry-over: build team challenges into the product), Amazon Prime retains through bundles of related services (carry-over: integrations with tools teams already use), education platforms through cohorts and deadlines (carry-over: synchronous team sprints instead of async work). The model gives 4-6 non-obvious analogies with explanations of how to adapt them.
Why it works
Adversarial Self-Correction works because it switches the model's mode. By default an LLM is in "assistant" mode: it generates plausible, supportive text. When you ask "check this plan," it looks for reasons the plan might work, not for where it will break. The three-step protocol forces the model to switch roles to critic. After the first analysis it has committed to a position. The second request ("where could you have gone wrong") activates the opposite thinking pattern: hunting for holes in its own arguments. That uncovers weak spots invisible in the normal mode.
Cross-pollination works because it plays to an LLM strength: finding patterns across domains. The model was trained on text from every field and sees structural analogies (e.g., "retention" in fitness = "retention" in SaaS: different mechanics, same principle). It's hard for a person to keep the whole range of industries in their head; the model does it instantly. The key: explicitly rule out the obvious field ("no SaaS tactics"), or the model will take the path of least resistance.
Scaffolding works because it reduces combinatorial complexity. Without structure, the model can "wander" through the space of possible approaches. When you give it a high-level outline ("first X, then Y"), it focuses on filling in details rather than choosing a direction. This is especially useful for complex multi-step tasks.
Control levers: - Number of iterations in Adversarial: 3 steps minimum, more for critical decisions → each round finds subtler errors - Off-limits fields in Cross-pollination: "don't look at X" → forces the search farther from the obvious - Scaffolding detail: you can give a 2-step strategy (the model fills in more) or a 10-step one (the model only fills in details)
Prompt template: Adversarial Self-Correction
# Step 1: Initial analysis
{Description of the task/problem/argument}
Analyze this: assess {what to assess}, find {what to find}.
---
# Step 2: Critique your own analysis
Now check your analysis:
1. Where might you have fallen into confirmation bias?
2. Which obvious counterarguments or risks did you miss?
3. What did you describe only superficially?
---
# Step 3: Final version
Taking the weak spots you found into account, give a final assessment.
Which {number} critical {aspects/assumptions/risks} matter most?
What to fill in:
- {Description}: your task, business plan, argument, solution
- {what to assess}: "viability," "logic," "risks"
- {what to find}: "weak spots," "assumptions," "counterarguments"
- {number}: how many key points you want (usually 2-3)
The three requests run one after another in the same chat. Important: don't merge them into one prompt. The model has to commit to a position first and then critique it.
Prompt template: Cross-Pollination
I have {description of the situation/problem}.
Find analogous {solution/problem} patterns in industries OUTSIDE {current field}.
Look at {list of other fields to search}.
Which mechanics/approaches/solutions carry over to my context?
What to fill in:
- {description of the situation}: the specific problem or goal
- {solution/problem}: what you're looking for: "customer retention," "monetization," "engagement"
- {current field}: where NOT to look (rules out the obvious)
- {list of other fields}: 3-5 specific industries or domains
Prompt template: Scaffolding
{Task description}
Here's a high-level strategy for solving it:
1. {Step 1}
2. {Step 2}
3. {Step 3}
Fill in the technical details for each step:
- What exactly to do
- Which tools/methods to use
- Which pitfalls to watch for
What to fill in:
- {Task description}: what needs to be solved
- {Step 1, 2, 3...}: high-level stages (anywhere from 2 to 10 steps)
Limitations
⚠️ Case-specific: The study focuses on theoretical math problems (proofs, algorithms, theorems). For non-math business tasks the principles are universal, but the specific examples from the study (finding counterexamples to conjectures, checking formal proofs) don't carry over directly.
⚠️ Three requests instead of one: Adversarial Self-Correction takes patience: you can't get deep critique from one prompt. If you try to cram all three steps into one message ("analyze AND check your analysis"), the model will cut corners: you'll get an analysis plus a token self-check with no real critique.
⚠️ You need basic domain knowledge: Cross-pollination produces analogies from other fields, but you have to judge whether they apply. The model might suggest a fitness-industry mechanic for SaaS without checking the unit economics or cultural differences between markets. Filtering out false analogies is on the human.
⚠️ Neuro-symbolic loops are beyond a chat: One of the techniques in the study (automated loops where AI writes code → runs it → reads the errors → fixes them) requires software infrastructure. It's not applicable in ChatGPT/Claude directly, though you can reproduce the principle (iterative checking with external validation) by hand.
How they studied it
The Google Research team collected 19 real cases of scientists working with Gemini Deep Think, an advanced version of the model with enhanced reasoning and parallel exploration of solutions (the model tries several proof strategies at once). Researchers from top universities (MIT, Harvard, Carnegie Mellon, EPFL) tackled open problems in their fields: algorithm theory, cryptography, graph theory, physics, economics.
The crucial detail: these aren't synthetic benchmarks but genuinely unsolved problems. For example, the Courtade-Kumar conjecture in information theory (open since 2013), or hunting a bug in a recent cryptography paper that claimed a breakthrough. In one case the model found a counterexample to a mathematical conjecture zero-shot (no examples, on the first try), right after the request "read this paper and solve any open problem from it." In another, it found a fatal error in a proof after the adversarial self-correction protocol: first a review, then a check of its own review for hallucinations, then a refinement of the logic.
The surprising result: simple techniques produce breakthroughs. Cross-pollination (carrying ideas between fields) solved a graph-embedding problem that had resisted closure for years: the model recalled an obscure theorem by Kirszbraun from functional analysis and applied it to a combinatorial problem. The adversarial protocol found a bug that human reviewers had missed. In normal mode the model missed it too, but after self-checking it noticed a mismatch between the definition (perfect consistency) and the construction (statistical consistency).
The main practical insight: AI works not as an oracle but as a junior colleague. Most of the 19 cases needed iteration: the researcher steers, the model generates hypotheses, the researcher checks. But scaffolding (give a high-level strategy and the model fills in the details) worked on problems where combinatorial complexity would otherwise paralyze the model. Context de-identification (removing "this is an open problem" from the prompt) is critical; otherwise the model refuses to try or becomes too conservative.
Resources
Accelerating Scientific Research with Gemini: Case Studies and Common Techniques
David P. Woodruff, Vahab Mirrokni and 30+ co-authors
Google Research, Carnegie Mellon University, MIT, Harvard, EPFL, Purdue and others
Works mentioned: - Korula et al. (2015): the submodular welfare conjecture - Gemini Deep Think [68]: a reasoning model with parallel exploration of solutions - Work on SNARGs from LWE [51]: the cryptography where the bug was found
Adaptations and extrapolations
💡 Adapting Adversarial Self-Correction for reviewing copy:
Use the three-step protocol to critique your own writing: articles, pitches, sales pages:
# Step 1
Here's my copy for a SaaS product landing page:
[text]
Assess: how convincing is it, which customer objections are left unanswered.
# Step 2
Check your assessment:
1. Where were you too soft?
2. Which obvious weaknesses in the copy did you miss?
3. What did you describe in generalities instead of specifics?
# Step 3
Given all that: which 3 passages are killing conversion?
After the second step, the model notices that in its first pass it wrote "overall not bad" about weak spots that are actually critical. It finds specific phrases where the logic breaks or the claim sounds implausible.
💡 Adapting Cross-Pollination for personal decisions:
Apply the technique to career or strategic choices:
I'm choosing between an offer at a stable corporation (more money,
less growth) and a startup (equity, risk, learning).
Find analogous "stability vs. growth" dilemmas in areas OUTSIDE careers.
Look at investing, sports, creative industries, entrepreneurship.
Which decision principles carry over? How do people in other fields handle this?
The model surfaces patterns: investors use a barbell strategy (90% safe + 10% aggressive), athletes pick the moment when they still have a safety margin but their form still allows risk, musicians combine steady session work with risky solo projects. It gives you a framework for your decision through the lens of other domains.
🔧 Combo: Adversarial + Cross-pollination for strategy:
For complex strategic decisions, use both techniques in sequence:
# Cross-pollination first
Problem: {your problem}
Find analogies in {other fields}
# Then Adversarial on the solution you found
Here's a strategy based on an analogy with {field}:
{strategy}
Now do an adversarial review of this strategy: 3 steps as above.
Cross-pollination produces an unconventional idea. Adversarial stress-tests it. Together they find a non-obvious solution AND vet it right away.