Improve parallel reasoning by explicitly generating diverse outlines before executing solution paths. Overcomes mode collapse where independent samples converge on same (often wrong) answer. Generates unique answers (27.6 vs 23.5) with focused reasoning (10% shorter correct paths).
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Improve parallel reasoning by explicitly generating diverse outlines before executing solution paths. Overcomes mode collapse where independent samples converge on same (often wrong) answer. Generates unique answers (27.6 vs 23.5) with focused reasoning (10% shorter correct paths).
OPE: Outline-Guided Path Exploration for Diverse Reasoning
Parallel reasoning via independent sampling often suffers mode collapse: most paths converge on the same answer rather than exploring solution space. This mutual information saturation means additional samples provide diminishing returns. OPE decomposes reasoning into planning and execution: explicitly generate diverse outlines partitioning the solution space, then execute reasoning paths following each outline. By structuring exploration upfront, the model explores distinct problem-solving directions rather than repeatedly finding the same (often incorrect) answer.
Core Concept
Standard parallel reasoning: sample k paths independently → mode collapse → diversity saturates.
OPE approach:
Outline Generation: Model generates k diverse outlines describing distinct solution strategies
Outline Diversity: Explicitly manage diversity among outlines (not just paths)
Guided Execution: For each outline, model generates reasoning path following that outline
Solution Coverage: Different outlines explore different regions of solution space
Key insight: managing diversity at the outline level (high-level structure) is more effective than at the path level (low-level tokens).
Architecture Overview
Outline Generator: Creates diverse high-level solution strategies
Diversity Metrics: Measure and enforce outline distinctness (embedding-based similarity)
Outline-Specific Prompts: Guide each reasoning path toward its outline
Path Voter: Select final answer via majority voting across diverse paths
"""
Args:
language_model: LLM for outline generation
num_outlines: Number of distinct outlines
diversity_threshold: Minimum cosine similarity between outlines
"""
self
self
self
self
'all-MiniLM-L6-v2'
def
generate_outlines
self, problem
"""
Generate diverse outlines for problem-solving.
Args:
problem: Problem statement
Returns:
outlines: List of diverse solution strategies
"""
f"""For the following problem, generate {self.num_outlines} distinct solution approaches.
Each approach should outline a different strategy or perspective.
Problem: {problem}
List {self.num_outlines} diverse solution strategies:
1.
2.
3.
..."""
# Generate initial batch
self
500
# Parse outlines
self
# Enforce diversity
self
return
def
_parse_outlines
self, text
"""Parse numbered outline list."""
import
r'\d+\.\s*(.+?)(?=\n\d+\.|$)'
return
for
in
if
def
_enforce_diversity
self, outlines
"""Remove similar outlines, regenerate if needed."""
for
in
# Embed outline
self
# Check similarity to existing
if
not
else
0
0
for
in
# Keep if sufficiently different
if
max
self
return
self
class
OutlineGuidedExplorer
"""Execute reasoning paths guided by outlines."""
def
__init__
self, language_model
self
def
execute_guided_path
self, problem, outline
"""
Generate reasoning path following specific outline.
Args:
problem: Problem statement
outline: Strategy outline to follow
Returns:
path: Full reasoning and solution
"""
f"""Solve this problem using the following approach:
Problem: {problem}
Approach to follow: {outline}
Now solve the problem step-by-step following this approach:"""
self
400
return
def
extract_answer
self, path
"""Extract final answer from reasoning path."""
import
# Look for answer markers
r'answer:\s*(.+?)(?:\n|$)'
r'solution:\s*(.+?)(?:\n|$)'
r'therefore,?\s*(.+?)(?:\n|$)'
r'the answer is\s*(.+?)(?:\n|$)'
for
in
match
if
match
return
match
1
# Fallback: last non-empty line
for
in
'\n'
if
return
1
if
else
""
def
vote_on_answers
self, paths
"""Select final answer via voting."""
self
for
in
# Count votes
from
import
1
0
0
return
class
OPEReasoner
"""Full outline-guided exploration system."""
def
__init__
self, language_model, num_outlines=5
self
self
def
solve_with_outline_guidance
self, problem
"""
Solve problem via outline-guided diverse exploration.
Args:
problem: Problem statement
Returns:
final_answer: Best answer via voting
reasoning_trace: All generated paths
"""
Higher = stricter diversity (fewer similar outlines).
Voting strategy
Majority vote
Simple and effective; can use confidence weighting.
Outline length
1-2 sentences
Concise direction; too detailed limits flexibility.
When to Use
Problems with multiple valid solution paths (math, reasoning)
Want to overcome mode collapse in sampling
Can afford multiple reasoning passes (k paths)
Need diverse correct answers (not just single solution)
When NOT to Use
Inference speed critical (k passes slower than single pass)
Single solution required (voting reduces to any answer)
Domains with single dominant approach
Common Pitfalls
Outlines too similar (diversity threshold too high)
Outlines too abstract (don't guide paths effectively)
Voting scheme breaks ties arbitrarily; use confidence weighting
Not measuring actual outline uniqueness; check embeddings
Reference
See https://arxiv.org/abs/2602.08344 for full empirical analysis on reasoning benchmarks, diversity metrics, and efficiency comparisons with standard parallel sampling.
