Foundations — Ripple-carry adder

Before you can read the parent note, you must own every symbol it uses without apology. This page builds each one from absolute zero: what it means, what it looks like, and why the topic needs it. Nothing here assumes you have seen a logic gate before.

1. A bit — the smallest thing there is

The picture: a light switch. Down = $0$ (off), up = $1$ (on). Every wire in the adder carries exactly one of these two states at any moment.

Why the topic needs it: the whole adder is made of wires, and each wire holds exactly one bit. Later, when we give those wires names, each name will point at one specific switch.

2. A binary number — bits lined up in columns

So the four bits $1011$ mean:

$1\cdot 8+0\cdot 4+1\cdot 2+1\cdot 1=11$

The picture: think of egg cartons of size $8,4,2,1$. A $1$ means "this carton is used", a $0$ means "empty". Add up the used cartons to get the decimal value.

Why the topic needs it: the adder takes two binary numbers $A$ and $B$ as input. Understanding "column worth doubles" is what makes carrying make sense.

3. LSB and MSB — the two ends of the number

The picture: in the number $1011$, flipping the right end ($1\to 0$) changes the value by $1$; flipping the left end changes it by $8$. Big end matters more.

Why the topic needs it: the parent note says the carry ripples from LSB to MSB. That is a direction — from the tiny-value end toward the big-value end. You cannot picture "ripple" without knowing which way is which.

4. Bit-width $n$ and subscripts $A_i$ — naming one bit out of many

The picture: a row of $n$ numbered mailboxes. For $n=4$, the number $A$ is $A_3{A}_2{A}_1{A}_0$ split into four labelled boxes; the box $A_i$ is "column $i$".

Why the topic needs it: the parent writes formulas with a placeholder $i$ so one line describes every column at once, whether the adder is $n=4$ or $n=64$ bits wide. Master the subscript and the whole adder collapses into a single stage you understand.

5. Carry — the bit that spills into the next column

The picture: water overflowing a small cup into the cup on its left. $C_i$ = the carry entering column $i$ from the right; $C_{i+1}$ = the carry leaving column $i$ toward the left.

Why the topic needs it: the carry is the entire reason the machines must be chained. Without carries every column would be independent and instant. The carry is the wave that makes it "ripple".

6. The sum bit $S_i$ — what actually gets written down

The picture: when you add $7+5=12$ on paper you write the $2$ (that is $S_i$) and carry the $1$ (that is $C_{i+1}$). In binary $1+1=10_2$: write $S_i=0$, carry $C_{i+1}=1$.

Why the topic needs it: the final answer of the adder is the whole row of sum bits $S_{n-1}\dots S_1{S}_0$, plus possibly a top carry $C_n$. Without $S_i$ there is no answer to read off.

7. XOR ($\oplus$) — "different?" in one gate

Why THIS tool? We need something that answers "is the count of $1$s odd?" Adding two bits with no carry, $0+1$ and $1+0$ give a sum bit $1$ (odd), while $0+0$ and $1+1$ give an even count → sum bit $0$. That is exactly XOR's table. When we chain three of them, $a\oplus b\oplus c_{in}$ is $1$ whenever an odd number of the three inputs are $1$ — which is precisely the sum bit. XOR is the "odd-parity detector", and parity is what a sum column needs.

The picture (its gate symbol): the curved-back shield below is the standard XOR drawing. Learn the shape now so the parent's circuit diagram is readable.

8. AND ($\cdot$) and OR ($+$) — the carry's two words

The picture (their gate symbols): the flat-backed "D" is AND; the curved-back shield with a pointed nose is OR. These three shapes (with XOR from Section 7) are the entire visual vocabulary of the parent's circuit.

Why the topic needs it: the carry-out uses AND and OR to say "any two inputs are $1$". We build that exact expression in the next section.

9. Truth table — the complete behaviour, no gaps

The picture: an exhaustive checklist. Three inputs $a,b,c_{in}$ ⇒ $2^3=8$ rows, no scenario left unlisted.

Here is the full-adder table, with $c_{in}$ meaning "carry coming in" and $c_{out}$ meaning "carry going out" (these are just $C_i$ and $C_{i+1}$ for a single column, written in lowercase when we look at one stage in isolation):

Deriving $c_{out}$ from the table (step by step, WHY it is majority):

1. WHAT we look for: the rows where $c_{out}=1$. From the table those are exactly rows $\{0,1,1\},\{1,0,1\},\{1,1,0\},\{1,1,1\}$ — the last four rows where the decimal sum is $2$ or $3$.
2. WHY those rows: $c_{out}=1$ precisely when the column total is $\ge 2$, and a total of $2$ or $3$ needs at least two of the three inputs to be $1$.
3. WHAT IT LOOKS LIKE as an expression: "at least two are $1$" = "($a$ and $b$) OR ($b$ and $c_{in}$) OR ($a$ and $c_{in}$)". Writing AND as juxtaposition and OR as $+$:

$c_{out}=ab+b{c}_{in}+a{c}_{in}$

Check it against the four rows: any two inputs being $1$ switches on one of the three AND-terms, so the OR fires — matching the table exactly. This "at-least-two-of-three" pattern is the majority function. That is why the carry is majority and not XOR: XOR asks "odd?", majority asks "at least two?" — different questions, different circuits.

Why the topic needs it: the parent derives the full-adder equations by staring at this 8-row table. The table is the ground truth; the formulas are just a compact way to say the same thing.

10. Full adder & half adder — the machine per column

The picture: a full adder is a box with three input wires and two output wires. Stack $n$ of them (one per column) and wire each one's $c_{out}$ into the next one's $c_{in}$ — that chain is the ripple-carry adder.

Why the topic needs it: the parent says "an $n$-bit RCA is $n$ cascaded full adders". Every foundation above exists so this sentence becomes obvious.

11. Propagation delay — why waiting happens

The picture: dominoes. Knock the first, and there is a tiny pause before the next tips. A carry rippling through $n$ stages is $n$ pauses in a row.

Why the topic needs it: this is the whole cost story. Because each carry waits for the one before it, the total delay grows like $n$ — written $O(n)$ — and that slowness is what motivates the faster Carry-lookahead adder.

How the foundations feed the topic

Equipment checklist

Connections

• Ripple-carry adder — the parent this page prepares you for.
• Full adder — the per-column machine built from these gates.
• Half adder — the two-input cousin, first-column only.
• Carry-lookahead adder — the faster design that beats $O(n)$ delay.
• Two's complement — where these bits and carries enable subtraction.
• Overflow detection — reading the top carries for signed results.
• Combinational circuits — the family RCA belongs to.
• Propagation delay — the timing idea behind "ripple is slow".