← 🔢 Number Representation & Computer Arithmetic
Subtopic 8 of 9

4.8Adders

The idea

A ripple-carry adder passes the carry along bit by bit, so it is slow. A carry-lookahead adder computes all carries at the same time.

Think of it like this: A queue where each person waits for the one before (ripple) versus everyone being told in advance (lookahead).

Why it exists

The adder is on the critical path of the CPU; carry delay limits clock speed.

How it works

  1. Ripple: carry of bit i waits for carry of bit i−1: delay grows with n.
  2. Lookahead: generate G = A·B and propagate P = A⊕B for each bit.
  3. Ci+1 = Gi + Pi·Ci, expanded so every carry depends only on inputs.
  4. Cost: more gates.

Worked example: 8-bit adder

Ripple: about 8 carry delays. Lookahead: about 2–3 gate delays for the carries.

Now play with it

  • →Compare the two tabs: the red C moves diagonally in ripple but is immediate in lookahead.
123456789
bit 0C········
bit 1C·······
bit 2C······
bit 3C·····
bit 4C····
bit 5C···
bit 6C··
bit 7C·

Each bit waits for the carry from the one below: delay grows linearly, ≈ n gate delays.

Check yourself

The delay of an n-bit ripple-carry adder grows approximately:

Remember: Ripple = O(n), lookahead = O(1) levels per group.
Exam notes (the dense version)

Ripple-carry: delay ∝ n. Carry-lookahead: G = A·B, P = A⊕B, Ci+1 = Gi + PiCi, all carries in constant gate depth (per group).

Previous year questions: Number Representation & Computer Arithmetic (19)

PYQs are grouped by topic, so this is the full set for Number Representation & Computer Arithmetic; try the ones that match this subtopic. Open all 19 on the topic page.