Reasoning Through Problems

When tasks require reasoning

Many tasks require reasoning that involves more than pattern matching or information retrieval: breaking down problems, applying logical steps, and working through solutions systematically. Mathematical calculations, logical puzzles, multi-step planning, and complex decision-making all benefit from explicit reasoning processes rather than direct pattern-based responses.

Older large language models failed at relatively simple arithmetic tasks (e.g., 23 + 47 + 4 - 2) because the models lacked the ability to perform multi-step calculations reliably. Modern models have improved but still struggle with complex reasoning without guidance.

Consider a practical example: baking chocolate cookies when you’re short on ingredients. Suppose a recipe that produces 50 cookies requires 200g of chocolate, 150g of butter, 2 dl of sugar, 1 egg, 3 dl of wheat flour, and a pinch of salt. If you only have 75g of butter, how many cookies can you make?

Let’s try asking the model using few-shot prompting to constrain the output format:

The answer should be 25 cookies (since 75g is half of 150g, yielding half of 50 cookies). The model has failed to reason correctly about the proportion, despite the examples provided.

This illustrates a common challenge: while language models can perform many tasks remarkably well, they sometimes struggle with tasks requiring multi-step reasoning, particularly when the reasoning process isn’t explicitly demonstrated in the prompt.

Chain-of-thought prompting

Chain-of-thought (CoT) prompting asks a model to generate intermediate reasoning steps before an answer. This can improve performance on some tasks, as demonstrated in chain-of-thought prompting experiments. Its effectiveness depends on the model, task, and prompt.

Generated steps become context for subsequent token predictions. This gives the model space to work through intermediate results. However, a plausible explanation is not necessarily a faithful account of what caused the answer: research has demonstrated misleading chain-of-thought explanations. Check the steps and the final result rather than treating the explanation as proof of correctness.

Few-shot chain-of-thought

Let’s revise our cookie problem to include explicit reasoning in the examples:

The examples demonstrate how to calculate the proportion. In this response, the model correctly calculates that 75g (half of 150g) produces 25 cookies (half of 50). One successful response illustrates the technique but does not establish that it will always work.

Zero-shot chain-of-thought

Surprisingly, chain-of-thought reasoning can be elicited without providing examples simply by adding phrases that prompt step-by-step thinking. The most well-known is “Let’s think step by step,” introduced in Large Language Models are Zero-Shot Reasoners in 2022. Variants like “Let’s work through this systematically” or “Let’s break this down” also work effectively.

This response includes a proportion and explicit mathematical steps. Such prompts can encourage useful intermediate calculations, but the effect varies across models and problems.

Advanced reasoning techniques

Researchers have developed several extensions to basic chain-of-thought prompting that improve performance on particularly challenging problems.

Self-consistency

Self-consistency generates multiple reasoning paths for the same problem and selects the most common answer through majority voting. Instead of accepting the first response, the system:

1. Generates several responses using chain-of-thought prompting with sampling to produce diversity; the number of responses is a design choice
2. Extracts the final answer from each response
3. Takes the majority vote among the answers as the final output

This approach can improve accuracy when different successful paths converge on the same answer while errors vary. However, responses from the same model can share the same misconception, so a majority can agree on a wrong answer. Agreement is not independent verification.

For example, asking a model to solve a complex math problem multiple times might yield:

• Response 1: [reasoning steps] → Answer: 42
• Response 2: [different reasoning steps] → Answer: 42
• Response 3: [yet different reasoning steps] → Answer: 38
• Response 4: [more reasoning steps] → Answer: 42
• Response 5: [final reasoning steps] → Answer: 42

Self-consistency would select 42 as the final answer based on the majority vote (4 out of 5 responses).

The trade-off is additional computation and cost. Responses may be generated sequentially or in parallel, affecting latency differently. For important decisions, verify the selected answer using reliable evidence or appropriate tools.

Tree of thoughts and graph of thoughts

Tree of thoughts extends chain-of-thought by exploring multiple reasoning paths simultaneously rather than committing to a single path. The approach:

1. Generates several possible next reasoning steps from the current state
2. Evaluates which steps seem most promising using a scoring mechanism
3. Explores multiple branches in parallel
4. Backtracks if a path seems unproductive based on evaluation
5. Continues until reaching satisfactory solutions

This mirrors how humans approach complex problems — trying different approaches, evaluating progress at intermediate stages, and switching strategies if necessary rather than following a single path to completion.

Graph of thoughts generalizes this further by allowing reasoning paths to merge and diverge arbitrarily rather than following a strict tree structure. This enables more flexible exploration of solution spaces where insights from different reasoning paths can be combined.

These techniques are primarily research directions rather than widely-deployed practical tools, but they illustrate ongoing work to improve reasoning capabilities beyond linear chains of thought.

Tool-augmented reasoning

Tool-augmented reasoning recognizes that language models shouldn’t solve all problems purely through text generation. For certain tasks — precise calculations, database queries, web searches, code execution — external tools are more reliable than the model’s internal reasoning capabilities.

In tool-augmented systems, the model:

1. Recognizes when a tool would be helpful for solving part of the problem
2. Generates a properly-formatted tool call with appropriate parameters
3. Receives the tool’s output
4. Incorporates that output into its ongoing reasoning
5. Continues until the problem is solved

For example, when asked “What’s the 47th Fibonacci number?”, a tool-augmented model might:

1. Recognize this requires precise calculation beyond its reliable capabilities
2. Generate Python code to calculate Fibonacci numbers efficiently
3. Execute that code using a code interpreter tool
4. Receive the result: 2,971,215,073
5. Return this precise answer with confidence

This approach combines the model’s language understanding and reasoning with the precision of computational tools, yielding more reliable results than pure text generation for many technical tasks.

Reasoning models

Recent developments have introduced a new class of models specifically designed for reasoning: reasoning models that use extended inference-time computation to solve complex problems more reliably.

How reasoning models differ

Ordinary autoregressive generation already uses more computation for longer prompts and outputs. Reasoning models can additionally allocate generation to intermediate reasoning before the final answer. Depending on the model and surrounding system, this can involve:

• Producing extensive chain-of-thought (or similar) reasoning that may not be shown to users but guides the final response. This internal reasoning can span thousands of tokens.

• Sampling multiple reasoning paths and selecting among their answers, as in self-consistency. This is an optional system technique, not a required property of every reasoning model.

• Generating checks or revisions of intermediate results. These may catch errors, but can also repeat or introduce mistakes.

Additional inference computation can improve task performance, at the cost of time and expense. It does not guarantee that the final answer is correct.

Practical guidance for reasoning tasks

When approaching tasks that require reasoning, seek to balance accuracy, cost, and latency:

1. Try direct prompting first: Many problems don’t require explicit reasoning techniques. Start with clear, direct prompts.
2. Add “Let’s think step by step”: If direct prompting fails or produces uncertain results, zero-shot CoT is a low-cost next step.
3. Use few-shot CoT: If zero-shot CoT is insufficient, provide explicit reasoning examples demonstrating the desired problem-solving approach.
4. Consider reasoning models: For particularly complex problems where accuracy matters more than speed or cost.
5. Apply advanced techniques: Self-consistency or tool augmentation for critical decisions requiring high confidence.

Regardless of the technique you end up with, always verify the outputs carefully.

Current turn: X
Board state:
X . O
. X .
O . .