TL;DR
DIP is a prompting technique that generates several different approaches to a task, expands each into a detailed plan, and then synthesizes a final plan from all the drafts. It works in three phases: divergence (5 different rationales), elaboration (5 draft plans) and induction (1 final plan). Only after the synthesis does the model carry out the solution.
LLMs tend to latch onto the first strategy they find and follow it to the end — a greedy approach. Methods like S-CoT or Plan-and-Solve generate a single strategy and build the entire line of reasoning on it. If the first intuition is wrong or incomplete, the model heads down a blind alley. The alternative — multi-path methods (Self-Consistency) — generates many complete solutions and takes a vote, but that's expensive in tokens (5-7x).
DIP taps the inductive capacity of LLMs: the model can synthesize patterns from examples. Instead of generating many complete solutions, DIP produces several draft plans and induces the final one from them. It's cheaper than multi-sampling and more effective than a single strategy — the model merges different perspectives into one high-quality plan.
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.
Method Blueprint
Each step runs as a separate request:
STEP 1: Divergent Phase
Input: the question
→ Generate N rationales (approaches to the solution)
STEP 2: Draft Plan Construction
Input: the question + N rationales
→ A detailed step-by-step plan for each rationale
→ Result: N draft plans
STEP 3: Inductive Phase
Input: the question + N draft plans
→ Synthesize a final plan from all the drafts
STEP 4: Inference Phase
Input: the final plan + the question
→ Reasoning + final answer
Recommended N: 5 to 7 (the sweet spot depends on the model and the task)
Example in Practice
Task: You're launching a ready-meal delivery service in Denver. You need to pick a go-to-market strategy in a market that already has DoorDash and Uber Eats. Budget for the first 3 months: $100,000.
Prompt (Step 1 — Divergence):
Task: choose a go-to-market strategy for food delivery in Denver.
DoorDash and Uber Eats are already there. Budget: $100,000 for 3 months.
Generate 5 different high-level approaches (rationales) to solving this task.
Each approach should be conceptually distinct from the others.
Format:
Rationale 1: [name of the approach]
[1-2 sentences on the core idea]
Rationale 2: ...
Prompt (Step 2 — Elaboration):
Task: [same task]
Rationales:
[paste the 5 rationales from Step 1]
For each rationale, develop a detailed step-by-step action plan.
Format:
Plan 1 (based on Rationale 1):
1. [step]
2. [step]
...
Plan 2 (based on Rationale 2):
...
Prompt (Step 3 — Induction):
Task: [same task]
I have 5 draft plans:
[paste all 5 plans from Step 2]
Analyze all the plans and synthesize a final, optimal plan
that integrates the best elements of each draft.
Prompt (Step 4 — Execution):
Final plan:
[paste the synthesized plan from Step 3]
Task: [same task]
Following this plan, develop the go-to-market strategy step by step.
Result:
Step 1 will produce 5 conceptually different approaches: for example, a niche play (healthy/organic food), a price war (undercutting), partnerships (with local restaurants), tech differentiation (an AI menu) and geography-first (nail one neighborhood perfectly).
Step 2 will expand each approach into a detailed plan with concrete steps, a budget and metrics.
Step 3 will synthesize a final plan from the strongest elements: a niche for the launch (focus) + partnerships (lower risk) + tech for retention + geography-first for marketing efficiency.
Step 4 will execute the strategy according to the synthesized plan — you'll get concrete actions with priorities and a budget breakdown.
Why It Works
LLMs generate text automatically and sequentially, following the pattern set by the first tokens. When a model lays out a single strategy at the start (as in S-CoT), it commits to that direction — every subsequent reasoning step is built around the first idea. If the intuition is wrong or incomplete, the model doesn't see the alternatives.
LLMs are good at induction — extracting general patterns from examples. It's the foundation of instruction induction, few-shot learning and rule extraction. A model can take several candidate solutions and synthesize a generalized rule or plan from them.
DIP applies this inductive capacity at the instance level: instead of one strategy, it generates several different approaches and elaborates each independently. Then the model receives all the drafts as "examples" and induces the final plan — combining the strengths of each and avoiding their weak spots. It's cheaper than generating many complete solutions (Self-Consistency) but more effective than relying on a single intuition.
Control levers:
- N (number of rationales): 5-7 is optimal. Fewer (N=3) — not enough diversity. More (N=10+) — can add noise and make induction harder.
- Divergence instructions: Strengthen the "conceptually distinct approaches" requirement if the model produces similar rationales.
- Draft plan format: Spell out requirements (concrete steps, metrics, resources) if the plans come out too abstract.
- Induction criteria: Add explicit requirements for the final plan ("integrate the best elements," "avoid each draft's weaknesses," "synthesize a hybrid approach").
Prompt Template
STEP 1: Divergence
Task: {task description}
Generate {N} different high-level approaches (rationales) to solving this task.
Each approach should be conceptually distinct from the others.
Format:
Rationale 1: [name]
[1-2 sentences]
Rationale 2: [name]
[1-2 sentences]
...
Rationale {N}: [name]
[1-2 sentences]
STEP 2: Elaboration
Task: {task description}
Rationales:
{paste the rationales from Step 1}
For each rationale, develop a detailed step-by-step action plan.
Format:
Plan 1 (based on Rationale 1):
1. [concrete step]
2. [concrete step]
...
Plan 2 (based on Rationale 2):
1. [concrete step]
2. [concrete step]
...
STEP 3: Induction
Task: {task description}
I have {N} draft plans:
{paste all the plans from Step 2}
Analyze all the plans and synthesize a final, optimal plan that:
- Integrates the best elements of each draft
- Avoids the weak spots of each approach
- Forms a coherent solution strategy
STEP 4: Execution
Final plan:
{paste the plan from Step 3}
Task: {task description}
Following this plan, solve the task step by step.
Show your reasoning at every step.
Placeholders explained:
- {N} — number of rationales, 5-7 recommended
- {task description} — your specific task
- {paste rationales/plans} — copy the output of the previous step
Limitations
⚠️ Task complexity: On simple tasks (facts, straightforward calculations) DIP is overkill — generating several approaches adds complexity with no payoff. Use it for multi-step reasoning where different strategies are possible.
⚠️ Cost: DIP takes 4 LLM requests (instead of 1 for Z-CoT). In tokens it's 2-3x more expensive than plain CoT, but 5-7x cheaper than multi-sampling methods like Self-Consistency at comparable quality.
⚠️ Latency: Sequential phases mean delay — you have to wait for each step before starting the next. Not suited to real-time scenarios.
⚠️ Rationale quality: If the LLM produces similar rationales (not enough divergence), induction adds less value. You may need stronger instructions or a larger N.
How They Tested It
The team tested DIP on 20 models from six families: Llama (3.3, 4 Scout, 4 Maverick), Mistral (Small 2/3/3.1, Medium 3, Large 2), Gemini (2.0 Flash Lite/Flash), GPT (4o mini, 4o, 4.1 Nano/Mini/Full, o4 Mini), Grok (3, 3 Mini High/Low). That's broad coverage — from 8B parameters to 400B+, including Large Reasoning Models with extended test-time compute.
Benchmarks: BIG-Bench Hard (BBH) — 27 tasks where LLMs fall short of human-level performance — and LiveBench Reasoning — fresh tasks with contamination controls. They compared against three baselines: Z-CoT (basic zero-shot CoT), S-CoT (state-of-the-art single-strategy) and R-CoT (a variant of S-CoT with a rationale instead of a strategy).
The results showed two patterns: On BBH, every model improved — from a modest +0.58% (Mistral Small 2) to an impressive +6.72% (Llama 4 Scout). On LiveBench, 17 of 20 models improved, some dramatically: Llama 4 Scout +30.5%, GPT 4.1 Mini +13%, o4 Mini +8.5%.
An interesting insight from the ablation studies: When they removed Rationale Generation (the DIP-R variant — plans are generated directly, without rationales), quality dropped on 9 out of 10 models. That proves the two-stage divergence (high-level approaches first, then elaboration) matters — generating plans directly yields less diversity.
They checked the effect of the number of rationales N: the optimum is between 5 and 7, but it depends on the model. At N=1 (single-strategy) it loses almost every time. Above N>7 some models start to degrade — apparently too many drafts add noise to the induction.
The cost-performance analysis is especially telling: DIP with 1,556 output tokens scores 84.46% on Llama 4 Scout, while Self-Consistency (k=20) uses 7,533 tokens for 84.17% — 4.8x more expensive with a worse result. Even counting all phases, DIP stays more efficient than multi-sampling approaches.
A case study on BBH Salient Translation Error Detection showed how it works under the hood: only DIP (N=5) induced a plan that explicitly checked every error type and the alignment of name families, which led to the correct answer. The baseline and N=1 produced generic plans and got it wrong.
Adaptations and Extrapolations
🔧 Technique: Make the draft plans visible → understand reasoning diversity
In the study, the draft plans serve as an intermediate stage before induction. But you can ask the model to show all the drafts in the final answer:
[add at the end of Step 4:]
Additionally:
1. Show which elements from which draft plans made it into the final solution
2. Explain why elements of the other plans were rejected
This gives you transparency — you see which alternative approaches were considered and why this particular synthesis was chosen.
🔧 Technique: Expert roles instead of abstract rationales → sharper diversity
Instead of "generate N different approaches," assign a specific role to each rationale:
Task: {task}
Generate 5 approaches to the solution from the perspective of:
1. The Pragmatist (focus on fast execution, minimal risk)
2. The Innovator (unconventional solutions, tech/creative)
3. The Analyst (data-driven, metrics, A/B tests)
4. The Strategist (long-term vision, market positioning)
5. The Optimizer (efficiency, cutting costs)
For each role — a rationale in that role's style.
Effect: Roles create sharper divergence — the model can't produce similar approaches because the style constraints differ. The induction step gets genuinely different perspectives.
🔧 Technique: Critique before induction → filter out weak elements
Add an intermediate step between Elaboration and Induction:
I have {N} draft plans:
[paste the plans]
For each plan:
1. Name 2-3 strengths
2. Name 1-2 weaknesses or risks
Then use this analysis to synthesize the final plan.
Effect: Explicit critique helps the model avoid blindly copying elements and instead deliberately pick the strong ones and skip the weak ones. This strengthens the inductive phase.
Resources
Diverge to Induce Prompting: Multi-Rationale Induction for Zero-Shot Reasoning
Po-Chun Chen, Hen-Hsen Huang, Hsin-Hsi Chen
Department of Computer Science and Information Engineering, National Taiwan University; Institute of Information Science, Academia Sinica, Taiwan
Related work cited in the paper: - Chain-of-Thought Prompting (Wei et al., 2022; Kojima et al., 2022) - Plan-and-Solve Prompting (Wang et al., 2023) - Strategic Chain-of-Thought / S-CoT (Wang et al., 2024) - Self-Consistency (Wang et al., 2022) - Instruction Induction (Honovich et al., 2023; Chen et al., 2024) - Tree-of-Thoughts (Yao et al., 2023)