Chain-of-Thought (CoT)

The defining characteristic of CoT is the generation of an intermediate reasoning chain. Instead of jumping directly to an answer, the model is prompted to articulate its logic, often mimicking human problem-solving steps like breaking down a math problem or evaluating premises in a logical argument. This explicit process makes the model's 'thinking' transparent and allows it to handle multi-step problems that require holding and manipulating intermediate values. For example, for the question 'If Alice has 5 apples and gives 2 to Bob, how many does she have left?', a CoT response would be: 'Alice starts with 5 apples. She gives away 2. So, 5 - 2 = 3. Alice has 3 apples left.'

CoT reasoning is an emergent ability that appears predominantly in large language models (typically with 100B+ parameters). Smaller models often fail to generate coherent, logical chains even when prompted with examples. This suggests that the capacity for decomposing problems and maintaining consistency across multiple reasoning steps is a function of model scale and the breadth of its pre-training data. The technique provides minimal to no benefit on simple tasks where the answer can be retrieved directly, but yields significant performance gains on complex benchmarks like GSM8K (math word problems) and CommonsenseQA.

CoT is most effectively deployed via few-shot prompting. The prompt includes several hand-crafted examples (shots) of a question paired with a detailed reasoning chain and the correct final answer. These examples serve as a template, instructing the model on the format and depth of reasoning required.

• Example Structure: Each shot contains: Q: [Question] A: [Step-by-step reasoning] Therefore, the answer is [Final Answer].
• Role: The examples condition the model to generate outputs in the same structured manner, activating its latent reasoning capabilities learned during pre-training. The quality and clarity of these exemplars are critical for performance.

CoT demonstrates dramatic improvements on tasks requiring mathematical deduction and symbolic manipulation. By decomposing a problem into arithmetic operations (addition, multiplication) or logical steps (if-then, substitution), the model reduces a complex query into a series of simpler, more reliable computations. This is crucial because LLMs are notoriously poor at direct arithmetic. CoT mitigates this by using the model's strength in pattern matching and instruction following to set up the correct sequence of operations, which are then executed more accurately step-by-step.

A key benefit of CoT is the mitigation of compositional generalization errors, where models fail to correctly combine known sub-skills to solve a novel problem. By forcing explicit decomposition, CoT prevents the model from attempting a holistic, often incorrect, guess. Each step focuses on a sub-problem, and the output of one step becomes the input for the next. This sequential processing mimics a state machine, reducing the cognitive load per step and increasing the likelihood of overall correctness. It effectively uses the model's context window as a scratchpad for intermediate results.

CoT is not an end-point but a foundation for more advanced reasoning frameworks. It enables and inspires subsequent techniques:

• Self-Consistency: Running the CoT process multiple times and taking a majority vote on the final answers, which improves robustness.
• Least-to-Most Prompting: Breaking a problem down into a list of sub-questions, solving them sequentially, a more structured form of CoT.
• Tree of Thoughts (ToT): Exploring multiple reasoning paths (branches) in parallel and using search algorithms to find the optimal chain.
• Program-Aided Language models (PAL): Generating executable code (e.g., Python) as the reasoning chain, which is then run by an interpreter to get the final answer, offloading computation.

CoT prompting is most famously applied to complex arithmetic and algebraic word problems. Instead of outputting a final number, the model is prompted to generate intermediate calculation steps.

Example Prompt: "Q: A bakery sold 12 cakes in the morning and 8 more in the afternoon. Each cake costs $15. How much money did they make? Let's think step by step."

Model Output (CoT): "The bakery sold 12 cakes in the morning. In the afternoon, they sold 8 more, so total cakes sold = 12 + 8 = 20 cakes. Each cake costs $15, so total money = 20 * 15 = $300."

This explicit reasoning allows for error checking and significantly improves accuracy on benchmarks like GSM8K and MATH compared to standard prompting.

CoT enables models to navigate puzzles requiring implicit world knowledge or logical deduction.

Use Cases:

• Spatial Reasoning: "John is east of Mary. Mary is east of Steve. Is John east of Steve? Let's reason step by step."
• Temporal Reasoning: "If the meeting starts 30 minutes after 2:45 PM and lasts 1 hour, what time does it end?"
• Analogical Reasoning: Solving pattern completion in sequences (e.g., A, C, E, G, ?).

By decomposing the problem, the model surfaces its latent knowledge step-by-step, making the reasoning process transparent and less prone to intuitive leaps that lead to errors.

In domains like physics, chemistry, or code debugging, CoT helps models emulate a systematic hypothesis-and-test approach.

Example - Code Debugging: "Q: This Python function to calculate factorial returns 0 for input 5. Why? def fact(n): result = 0; for i in range(1, n+1): result *= i; return result Let's analyze line by line."

Model Output (CoT): "1. result is initialized to 0. 2. The loop multiplies result by i. Since 0 * anything = 0, result stays 0. 3. The fix is to initialize result = 1."

This structured breakdown is crucial for tasks on benchmarks like ScienceQA or Big-Bench Hard, where answers require integrating multiple facts.

CoT is often the foundation for more sophisticated reasoning techniques:

• Self-Consistency: Instead of sampling one CoT, the model generates multiple reasoning paths and selects the most consistent final answer through majority voting. This acts as a probabilistic ensemble, dramatically boosting accuracy.
• Least-to-Most Prompting: A two-stage method where the model first breaks a complex problem into sub-problems, then solves each sub-problem sequentially using CoT. This is particularly effective for problems harder than those seen in the prompt's few-shot examples.

These methods treat CoT not as a single path but as a search space for the most reliable reasoning trajectory.

The quantitative impact of CoT prompting is well-documented on standard reasoning benchmarks:

• GSM8K (Grade School Math): Standard prompting: ~20% accuracy. CoT prompting: ~60% accuracy.
• MATH (Challenging Math Problems): CoT enables models to tackle problems requiring multiple theorem applications.
• Big-Bench Hard (BBH): CoT, especially with self-consistency, closes a significant portion of the gap between large model performance and average human rater performance on 23 challenging tasks.

These metrics validate CoT as a critical tool for unlocking the complex reasoning capabilities latent in large language models.

The ReAct (Reasoning + Acting) paradigm integrates CoT with the ability to take actions, such as querying an external API or knowledge base.

Process:

1. Thought: The model reasons about what it needs to do next (CoT step).
2. Action: It executes a tool call (e.g., Search["current weather in London"]).
3. Observation: It receives the result from the tool.
4. It repeats this loop until it can formulate a final answer.

Example: For a question like "Who was the oldest person to win an Oscar, and how old were they?", the model might reason to first search for Oscar winners, then find their birth dates, then calculate ages. This combines logical decomposition with factual grounding.

A technique for controlling the output of conditional diffusion models by blending the predictions of a conditional and an unconditional model during sampling. This eliminates the need for a separate, pre-trained classifier to guide generation.

• Mechanism: The model is trained to perform both conditional and unconditional denoising. During inference, the final prediction is an extrapolation between these two modes.
• Guidance Scale: A hyperparameter (often s or CFG scale) controls the strength of conditioning. Higher values increase adherence to the condition but can reduce sample diversity.
• Application: It is the standard control mechanism in models like Stable Diffusion, enabling precise text-to-image generation.

An architecture that conditions a generative language model on relevant information retrieved from an external knowledge source, such as a vector database or search engine.

• Purpose: Enhances factual accuracy and reduces hallucinations by grounding the model's responses in verifiable data.
• Process: A query triggers a retrieval step to fetch relevant documents or data snippets. These are then injected into the model's context window alongside the original prompt.
• Relation to CoT: RAG provides the factual premises for a Chain-of-Thought. A model might first retrieve evidence, then reason step-by-step over that evidence before formulating a final answer.

A neural network mechanism that allows a model to condition its generation process on a separate sequence of data by computing attention weights between two different sets of embeddings.

• Function: Enables modalities to interact. For example, in a text-to-image model, cross-attention layers allow image feature maps to "attend to" relevant text token embeddings.
• Architecture: A core component of transformer-based multimodal models. The keys and values come from the conditioning signal (e.g., text), while the queries come from the data being generated (e.g., image latents).
• Role in CoT: While CoT is a sequential reasoning process, cross-attention is the underlying architectural primitive that allows a model to focus on specific parts of a prompt or retrieved context during each reasoning step.

A training methodology used to align generative models with complex human preferences and instructions, which often implicitly require multi-step reasoning.

• Process: Involves training a reward model on human comparisons of model outputs. This reward model then guides the fine-tuning of the base generative model via a reinforcement learning algorithm like PPO.
• Objective: Teaches the model not just to generate plausible text, but to generate helpful, harmless, and honest responses—capabilities that benefit from implicit CoT.
• Connection: RLHF can be used to reinforce models for producing clear, logical reasoning traces (CoT) when such outputs are preferred by human raters, directly optimizing for explainability.

An algorithm for fine-tuning generative models to align with human preferences by directly optimizing a policy using a loss function derived from pairwise comparison data.

• Advantage over RLHF: Circumvents the need to train and sample from a separate reward model, making the alignment process more stable and computationally efficient.
• Mechanism: It re-frames the reinforcement learning problem as a direct classification loss between preferred and dispreferred completions for a given prompt.
• Relevance to CoT: DPO can be applied with preference data where the "preferred" completion includes a correct Chain-of-Thought, thereby directly training the model to invoke reasoned steps before answering.

The capability of a sufficiently large language model to generate a step-by-step reasoning process for a novel task without requiring task-specific examples in its prompt.

• Trigger: Typically activated by appending phrases like "Let's think step by step" to the original query.
• Significance: Demonstrates the model's emergent ability to decompose problems and apply logical operations, a form of in-context learning without examples.
• Limitations: Success is highly dependent on model scale and the inherent structure of the problem. Performance is often surpassed by few-shot CoT, which provides exemplars of the reasoning process.