Apply to my task
arXiv:2602.03837 ★ 77 Feb 3, 2026

Gemini Case Studies: Techniques for Working with AI on Hard Problems

Key result

By default an LLM acts like a defense attorney. Ask it to “check this plan” and it looks for why the plan will work, not where it will break. Hence the shallow answers to hard questions. Techniques from real Google science cases (disproving mathematical conjectures, finding bugs in cryptography) let you catch fatal flaws in logic, the kind people miss. In one case Gemini found a critical bug in a cryptography paper that had made it past human reviewers. Adversarial Self-Correction flips the model into critic mode through three requests. The first is a normal analysis where the model commits to a position. The second, “where could you have gone wrong,” forces it to hunt for holes in its own arguments. The third is a final assessment that accounts for the weaknesses found. Result: it finds weak spots that stay invisible in a single-shot request.

01

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.

02

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
03

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.

04

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)

05

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.

06

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

07

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)

08

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.

09

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.

10

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

11

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.

Research digest

Key result

By default an LLM acts like a defense attorney. Ask it to “check this plan” and it looks for why the plan will work, not where it will break. Hence the shallow answers to hard questions. Techniques from real Google science cases (disproving mathematical conjectures, finding bugs in cryptography) let you catch fatal flaws in logic, the kind people miss. In one case Gemini found a critical bug in a cryptography paper that had made it past human reviewers. Adversarial Self-Correction flips the model into critic mode through three requests. The first is a normal analysis where the model commits to a position. The second, “where could you have gone wrong,” forces it to hunt for holes in its own arguments. The third is a final assessment that accounts for the weaknesses found. Result: it finds weak spots that stay invisible in a single-shot request.

Principle

Three requests in one chat, each changing the model's role: Request 1 (Analysis): The model is in assistant mode, generating plausible, supportive text. You give it the task; it analyzes and commits to a position. Request 2 (Self-critique): “Where might you have fallen into confirmation bias? Which counterarguments did you miss?” This activates the opposite pattern. The model is forced to critique its own text from the first answer. It looks not for why it's right but for where it went wrong. Request 3 (Final): A synthesis that accounts for the holes found; the model gives a tough assessment of the critical assumptions. Important: don't merge them into one prompt. If you ask “analyze AND check yourself” in one message, the model will cut corners and give a token self-check with no real critique.

Why it works

Switching the thinking mode is why it works. By default an LLM is in cooperative-assistant mode. It's trained to be helpful and generate text that supports the user's request. When you ask it to “evaluate a business plan,” the model subconsciously looks for why the plan might work, not for critical holes. That's confirmation bias, the same bias humans have. The three-step protocol breaks this pattern. After the first analysis, the model has committed to a position in writing. The second request forces it to attack its own text: find where it was superficial, what it missed, which counterarguments it ignored. That activates adversarial thinking. A real result from the study: the method found a fatal error in a cryptographic proof (the paper had already passed human review). The reason: the reviewers read in "understand the author's argument" mode, not "break the proof" mode. Adversarial Self-Correction switched the model into exactly the logic-breaking mode.

When to apply

Hard analytical tasks where mistakes are costly → vetting business plans before pitching investors, evaluating strategic decisions (product launch, repositioning), auditing the reasoning in important documents (specs, contracts). Especially when you can't see the weak spots yourself because you're emotionally invested: your idea, your project, your logic. Adversarial Self-Correction plays devil's advocate. Other techniques from the cases: - Cross-pollination (look for analogies in other fields): when you're stuck and the standard approaches don't work - Scaffolding (give a strategy and the model fills in the details): for complex multi-step tasks where you're afraid of missing details NOT a fit for: Simple factual questions, tasks that need a quick answer (three requests take time), content generation where critique isn't needed.

Mini recipe

Adversarial Self-Correction (three requests in sequence): 1. Initial analysis: Describe the task/plan/argument. Ask: `Analyze this: assess [what to assess], find [what to find]`. The model gives an initial answer and commits to a position. 2. Self-critique: `Now check your analysis: 1) Where might you have fallen into confirmation bias? 2) Which obvious counterarguments did you miss? 3) What did you describe only superficially?` The model attacks its own first answer. 3. Final assessment: `Taking the weak spots you found into account, give a final assessment. Which 2-3 critical assumptions could kill the idea?` A synthesis that incorporates the critique. Cross-Pollination (one request): `I have [problem]. Find analogous [solution] patterns in industries OUTSIDE [current field]. Look at [3-5 other fields]. Which mechanics carry over?` Scaffolding (one request): `Here's a high-level strategy: [step 1, 2, 3]. Fill in the technical details for each step: what exactly to do, which tools, which pitfalls.`

Examples

Adversarial Self-Correction for a business idea: [BAD]: `Check my idea: online AI courses for middle managers, priced at $199-$399. Is the idea viable?` The model gives an upbeat analysis with generic risks like “competition” and “finding an audience.” Superficial. [GOOD]: three requests: Request 1: `Here's a business idea: online courses on applying AI for middle managers in the US. Target audience: department heads aged 30-45; monetization via $199-$399 courses and corporate packages. Analyze it: assess viability, risks, assumptions.` Request 2 (after getting the answer): `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 admits it didn't check whether the audience will pay that much, whether overloaded managers have the time, or whether you can prove your expertise. Request 3: `Taking the weak spots you found into account, give a final assessment. Which 2-3 critical assumptions could kill the idea?` The model 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 retention: [BAD]: `How do I boost retention in a SaaS for project teams? We've already tried all the standard tactics.` [GOOD]: `I have a SaaS for project management in teams of 5-15 people. Problem: customers churn after 2-3 months. Find analogous retention patterns in industries OUTSIDE SaaS: look at retail, fitness, media subscriptions. Which mechanics carry over to my context?` The model shows: gyms retain members through group classes → build team challenges into the product; Amazon Prime through bundles of related services → integrations with tools teams already use; education platforms through cohorts and deadlines → synchronous sprints instead of async work.

In plain words

Gemini Deep Think and similar deep-reasoning models don't just work as fast encyclopedias; they act as digital analysts that can expose errors where the human eye gives up. The point isn't that the model “got smarter” but that it learned to imitate the verification process. In the science cases, this let the model find bugs in cryptography and tear apart mathematical conjectures that seemed true. The big shift here is from plain text generation to multi-layered logic checking, where every step gets questioned.

It's like hiring a brilliant but overly polite employee. If you ask, “So what do you think of my plan?”, they'll say it's great just to avoid upsetting you. But if you make them write a list of reasons this plan is total garbage, they'll suddenly hand you a dozen critical vulnerabilities. Google's study proves it: to squeeze the most out of AI, you have to make it argue with itself, or you'll just get pretty yes-man answers.

The key method here is Adversarial Self-Correction. It works in three moves: first you ask the model to solve the problem, then you flat-out order it to find the errors in its own answer, and only then you make it put together a final version that accounts for all the screwups. Specificity is what matters: when the model is forced to look for “where I could have gone wrong,” it switches its pattern from “be helpful” to “be a skeptic.” In testing, this helped find errors in proofs that people had missed for months.

Google tested this on hardcore science, but the principle is universal for any complex work. It fits perfectly for vetting business strategies, legal contracts or code architecture. If you need to know whether your startup will flame out or whether the logic of a complex report will fall apart, you use the same protocol. SEO for robots, logic for meaning: whether you're writing a formula or a plan to take over a market, the “critic inside the machine” mechanism takes the result to a new level.

Bottom line: stop using chatbots as an information desk and start using them as aggressive reviewers. The study's main takeaway is that the model is inclined to agree by default, and that's its biggest weakness. To avoid getting “a hallucination in pretty wrapping,” always run important decisions through a self-critique loop. Whoever learns to pit the model against its own conclusions will get solutions that work, while everyone else drowns in polite, useless content.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Gemini Case Studies: Techniques for Working with AI on Hard Problems arXiv:2602.03837

Sign in to apply this study New accounts get 50 free credits.