Analogic Reasoning Prompt

The prompt explicitly defines two components: a source problem (a known, solved example) and a target problem (the novel task). The instruction focuses the model on identifying the structural or relational isomorphism between them, rather than surface-level similarities.

• Example: "Solve this physics problem by analogy to the provided economic supply-and-demand problem. Map 'force' to 'price pressure' and 'mass' to 'inventory'."
• The goal is transfer learning within a single inference call, enabling the model to apply a known solution pattern to a new domain.

Effective prompts don't just present two problems; they guide the mapping process. This often involves:

• Highlighting key relationships in the source (e.g., "Notice how A inversely affects B").
• Instructing the model to articulate the analogy (e.g., "First, explain how the target problem is structurally similar to the source").
• Forcing abstraction away from domain-specific terminology to uncover the underlying logical form.

This reduces the risk of the model getting stuck on superficial details and failing to transfer the core solution mechanism.

Unlike simple few-shot examples, the source problem must be presented with its complete solution and reasoning trace. The model needs to understand why the source solution works, not just what the answer is.

• This often incorporates a Chain-of-Thought explanation for the source.
• The source should be a prototypical, clearly-structured example of the solution pattern to be transferred.
• The fidelity of the source reasoning directly impacts the model's ability to perform accurate cross-domain mapping.

A primary technical benefit is overcoming a model's domain-specific priors. A model might have strong heuristics for math word problems but weak ones for legal reasoning. By framing the legal problem as analogous to a mathematical one, the prompt bypasses weak domain modules and leverages stronger, more general reasoning patterns.

• This forces the model into a meta-cognitive mode, reasoning about reasoning patterns.
• It is a direct prompt engineering method for eliciting fluid intelligence—the ability to solve novel problems—over crystallized knowledge.

While both use examples, the intent and mechanism differ:

• Few-Shot CoT: Provides examples of the same type of problem to demonstrate the format of reasoning. It's a demonstration of process.
• Analogic Reasoning: Provides a different type of problem to demonstrate a transferable structural pattern. It's a demonstration of relational mapping.

Key Difference: Few-Shot CoT teaches "solve problems like this." Analogic Reasoning teaches "solve this problem as if it were that."

When poorly constructed, these prompts lead to characteristic errors:

• Superficial Mapping: The model maps elements based on word overlap or trivial features, not deep structure.
• Incomplete Transfer: Only part of the solution logic is transferred, leading to an invalid or partial answer.
• Reasoning Collapse: The model ignores the source and solves the target directly using its default (and potentially weaker) heuristics for that domain.
• Analogy Breakdown: The analogy is forced where no valid structural isomorphism exists, producing nonsensical reasoning.

Successful design requires careful selection of a source problem with a verifiably isomorphic structure.

Chain-of-Thought Prompting is a foundational technique that instructs a language model to generate a step-by-step reasoning trace before producing a final answer. By decomposing a problem into intermediate steps, it significantly improves performance on arithmetic, commonsense, and symbolic reasoning tasks.

• Core Mechanism: Appends phrases like 'Let's think step by step' or provides few-shot examples with explicit reasoning chains.
• Key Benefit: Makes the model's 'thought process' observable, allowing for error diagnosis and correction.
• Example: For a math word problem, the model outputs 'First, calculate the total cost of apples. Then, subtract from the budget...' before giving the final numeric answer.

Tree of Thoughts is a framework that generalizes Chain-of-Thought by modeling reasoning as a heuristic search over a tree structure. Each node represents a partial 'thought' or intermediate state, allowing the model to explore multiple reasoning paths, backtrack from dead ends, and evaluate options.

• Core Mechanism: Generates multiple potential next steps, evaluates their promise, and selects the best path to continue expanding.
• Key Benefit: Enables deliberate planning and global search for problems where a single linear chain is insufficient (e.g., game playing, strategic planning).
• Contrast with Analogic Reasoning: While ToT searches a space of solution steps, analogic reasoning searches for a structural mapping from a known source problem.

Program of Thoughts is a prompting method where a language model generates executable code (typically Python) as an intermediate reasoning step. The code is then run in an external interpreter to obtain precise, verifiable results, especially for mathematical and algorithmic tasks.

• Core Mechanism: The prompt instructs the model to 'write code to solve the problem' and then execute it.
• Key Benefit: Offloads exact computation to a deterministic runtime, eliminating arithmetic errors and hallucinations common in pure text-based reasoning.
• Relation to Analogic Reasoning: Both use an external structure—PoT uses code syntax and logic; analogic reasoning uses the relational structure of a source domain.

Self-Consistency is a decoding strategy used to improve the robustness of Chain-of-Thought reasoning. Instead of taking a single reasoning path, the model samples multiple, diverse reasoning chains for the same problem and selects the final answer that appears most frequently among the generated outputs.

• Core Mechanism: Leverages stochastic sampling to generate many potential reasoning paths, then uses majority voting on the final answers.
• Key Benefit: Mitigates the problem of individual reasoning chains going astray; the aggregate answer is often more reliable.
• Application: Can be combined with analogic reasoning by generating multiple analogical mappings and selecting the most consistent solution.

Least-to-Most Prompting is a technique that decomposes a complex problem into a sequence of simpler sub-problems. The model solves these sub-problems incrementally, with the solution to each sub-problem potentially used to solve the next, guiding the model toward the final solution.

• Core Mechanism: Uses a two-stage prompt: first to decompose the original problem, then to solve the sub-problems sequentially.
• Key Benefit: Reduces complexity by breaking down tasks the model might fail to solve in one step.
• Contrast with Analogic Reasoning: Least-to-Most is a decomposition strategy, while analogic reasoning is a transfer strategy. They can be complementary: an analogical mapping might suggest how to decompose a novel problem.

A Causal Reasoning Prompt is designed to elicit a language model to identify cause-and-effect relationships, distinguish correlation from causation, and reason about interventions and counterfactuals. It moves beyond pattern recognition to structured causal inference.

• Core Mechanism: Uses prompts that ask 'What would happen if X?' or 'Why did Y occur, and what was the necessary cause?'
• Key Benefit: Essential for tasks in diagnostics, root-cause analysis, and strategic planning where understanding mechanisms is critical.
• Relation to Analogic Reasoning: Both require deep structural understanding. Causal reasoning identifies dependencies within a single system; analogic reasoning maps dependencies across two different systems.