Exercises — Chain-of-thought prompting

$q\to (r_1,r_2,\dots ,r_k)\to a$ The question first produces a chain of intermediate reasoning steps $r_1\dots r_k$, and only then the answer $a$. The answer is read off the tail of the generation.

• (a) Few-shot CoT — it supplies exemplars (worked demonstrations). See Few-shot In-context Learning.
• (b) Zero-shot CoT — no exemplars, only a trigger phrase.

Count each distinct answer: $12$ appears 3 times, $8$ once, $7$ once. Majority vote returns $\boxed{12}$ with 3 out of 5 votes.

• Start state: $15$ books. (Why? Anchor the initial quantity before any operation.)
• Remove 9: $15-9=6$. (Why? Do events in the order they happen.)
• Delivery: $4\times 5=20$ books arrive. (Why? Compute the sub-quantity before combining.)
• Add: $6+20=26$.
• The answer is 26.

• 3 painters → 3 walls in 3 hours, so each painter paints 1 wall in 3 hours. (Why? Normalise to a per-painter rate; that's the invariant quantity.)
• 9 painters each paint their own wall in parallel, still 1 wall in 3 hours each.
• So 9 walls are finished in 3 hours.
• The answer is 3 hours.

Q: What is 10 + 6 - 4?
A: Start with 10 + 6 = 16. Then 16 - 4 = 12.
   The answer is 12.

Q: What is 17 + 25 - 8?
A:

The exemplar demonstrates the format ("reason first, then 'The answer is X'"). The model pattern-matches: $17+25=42$, then $42-8=34$. The answer is 34.

One answer token = one forward pass of compute, and everything the problem needs must be squeezed into that single pass. A hard problem needs more sequential steps than one pass can perform. Each reasoning token buys another forward pass, and — crucially — that token is fed back into the context. So the chain lets the model:

1. Buy more compute — $k$ reasoning tokens $\approx k$ extra forward passes, i.e. deeper effective computation.
2. Externalise memory — partial results (like "$=6$") are written down, so they needn't survive inside one hidden state. The weights are unchanged; CoT changes only how much serial computation the model is allowed to spend.

The sum runs over reasoning paths $r$. A correct answer $a^{\star }$ can be reached by many different valid paths $r$ — each contributes probability mass $p(a^{\star }\mid r,q)p(r\mid q)$, and these mass contributions pile up on the same answer. A wrong answer usually comes from a lone idiosyncratic error — one stray path — so its mass is scattered thinly across many different wrong answers. Sampling $N$ chains (needs Temperature and Sampling with temperature $>0$ for diversity) and counting the winner is a Monte-Carlo estimate of that marginal sum. The estimate concentrates on the answer with the most independent supporting paths — exactly $a^{\star }$. This is Self-Consistency Decoding.

At temperature $0$ decoding is deterministic — the model always picks the single highest-probability next token, so every "sample" is the same chain. Voting over 20 identical chains gives no benefit over 1. Self-consistency needs diverse chains, which requires a temperature $>0$ (e.g. $\approx 0.5$–$0.7$) so sampling explores different reasoning paths $r$. Only then does the vote aggregate independent routes. See Temperature and Sampling.

Number of correct chains follows a binomial with $n=3$, $p=0.6$. Majority (≥2 correct): $P(\ge 2)=\left(\genfrac{}{}{0ex}{}{3}{2}\right)p^2(1-p)+\left(\genfrac{}{}{0ex}{}{3}{3}\right)p^3.$ $=3(0.6{)}^2(0.4)+(0.6{)}^3=3(0.36)(0.4)+0.216=0.432+0.216=\mathrm{0.648.}$ So majority-of-3 gives $0.648$ vs a single chain's $0.6$ — a +0.048 improvement. Voting helps because errors don't coordinate on one wrong answer.

Combine CoT with retrieval (Retrieval-Augmented Generation):

1. Retrieve documents relevant to the question and place them in the context.
2. Prompt with CoT so the model reasons over the retrieved evidence step by step ("The document says the patent was filed in …; therefore …"). This targets CoT's core weakness: CoT adds reasoning compute but cannot invent missing facts — reasoning over a wrong premise still yields a wrong answer. RAG supplies the grounded premise; CoT chains the logic on top. (A tool-using variant that interleaves reasoning with actions is ReAct.)

This is Tree of Thoughts: instead of one straight line $r_1\to r_2\to \dots$, the model expands multiple candidate next-steps at each node, scores partial chains, keeps promising branches, and prunes/backtracks on dead ends — a deliberate search over reasoning states. Worth it when the problem needs exploration and lookahead (puzzles, planning, games) where a single greedy chain commits early to a bad path. For simple arithmetic it's overkill — plain CoT or self-consistency (Self-Consistency Decoding) is cheaper.

Not a prompt bug. CoT gains are largely emergent with scale (Emergent Abilities of LLMs) — they appear strongly only in large models (roughly ≳ 10B params in the original work). CoT unlocks a latent ability; it cannot create one the model lacks. A small model, when forced to write a chain, produces fluent-but-wrong reasoning that actively steers it into a bad answer — so it can score worse than just guessing directly. The fix is scale (or a smaller task), not a better trigger phrase.

This assumes the chain is the causal cause of the answer — but CoT chains can be post-hoc rationalisations (the faithfulness problem). The model may compute the answer by some hidden shortcut and then generate a plausible-sounding justification that had no causal role. Consequences: (i) a correct answer does not validate the chain, and (ii) a correct-looking chain does not guarantee a correct answer. To test faithfulness you must intervene — e.g. corrupt a step and see whether the final answer actually changes.

A layered pipeline:

1. Retrieve evidence — Retrieval-Augmented Generation — because the weights alone may lack the facts.
2. Few-shot CoT exemplars — Few-shot In-context Learning — to demonstrate the reason-then-answer format on this task type.
3. Sample $N$ chains at temperature $\approx 0.6$ — Temperature and Sampling — to get diverse independent reasoning routes over the retrieved evidence.
4. Majority vote — Self-Consistency Decoding — to concentrate mass on the most-supported answer and cancel idiosyncratic errors.
5. (Optional) Tree search — Tree of Thoughts — if the problem needs branching/backtracking rather than linear chains.
6. Use a large enough model — Emergent Abilities of LLMs — since CoT benefits are emergent with scale.

Recognise the pieces → apply to write chains → analyse why compute/voting work → synthesise with RAG/ToT → master the limits (emergence, faithfulness, systematic bias).