Parity generators - checkers: Visual walkthrough — Hardware deep dive

This is the visual walkthrough of parity generation and checking. We start with nothing but light bulbs that are ON or OFF, and we slowly build the exact circuit that catches a flipped bit. Every symbol is drawn before it is used. Follow the pictures — the words only point at them.

Step 1 — What is a "bit" and what does "flip" mean?

WHAT. A bit is one tiny fact that can only be in two states. We draw it as a bulb: ON $= 1$ , OFF $= 0$ . A word is a row of these bulbs, e.g. $101$ is (ON, OFF, ON).

WHY. Every idea on this page is really just "how many bulbs are ON?". Before we can count, we must agree on what we are counting.

PICTURE. In the figure, the top row is the message the sender wants to send. The one bulb that got hit by noise (a lightning bolt) flips: it swaps ON↔OFF. That single swap is the enemy we want to detect.

Step 2 — Counting ON bulbs is hard; asking "is the count odd?" is easy

WHAT. We do not need the exact count of ON bulbs. We only need one yes/no fact: is that count odd? Call this fact the parity of the word.

WHY. A flip changes the count by $\pm 1$ . Adding or subtracting $1$ always turns an odd number even and an even number odd. So a flip always flips the parity — that is the property that will let us catch it. The full count carries more information than we need; parity is the cheapest thing that still notices a single flip.

PICTURE. The figure sorts words into two buckets: EVEN-many ON (left, violet) and ODD-many ON (right, magenta). Every lightning arrow crosses from one bucket to the other. There is no arrow that stays inside a bucket — that is the guarantee we will build on.

Step 3 — The gate that measures "odd count of two bulbs": XOR

WHAT. We need a machine that eats bulbs and outputs $1$ when an odd number are ON. Start with just two inputs. The gate that does this is XOR, written $a \oplus b$ (the symbol $\oplus$ is a plus inside a circle — read it "x-or"). See XOR and XNOR gates for the gate itself.

WHY XOR and not AND or OR? Look at what each gate really asks:

$a AND b$ asks "are both ON?" — that is not a count of oddness.
$a OR b$ asks "is at least one ON?" — this says $1$ for one ON and for two ON, so it cannot tell odd from even.
$a \oplus b$ says $1$ for exactly one ON and $0$ for zero or two ON. One is odd, zero and two are even. That is literally "is the count odd?"

PICTURE. The figure draws all four input pairs as pairs of bulbs, with the XOR output beside each. The output lights up precisely on the two "one-ON" rows — the odd rows.

Step 4 — Chaining XORs: measuring oddness of MANY bulbs

WHAT. Real words have many bits. We feed them through a chain of XORs: $X = d_{0} \oplus d_{1} \oplus d_{2} \oplus \dots \oplus d_{n - 1}$ Here each $d_{i}$ is one data bulb ( $i$ is just its position number, $0$ up to $n - 1$ ), and $X$ is the single output bit at the end of the chain.

WHY it still means "odd?". XOR is associative — grouping does not matter, so we may fold the bits in one at a time, left to right. Each new bit either adds an ON (an extra $1$ ) or an OFF (nothing). Folding an OFF leaves the running answer alone; folding an ON toggles it. Toggling once per ON bulb means the final answer $X$ is ON exactly when an odd number of ON bulbs were folded in. So $X = 1 ⟺$ the word has an odd number of $1$ s. The two-input rule from Step 3 has grown into an $n$ -input rule for free.

PICTURE. The figure shows a staircase of XOR gates. Watch the running value on the wire between gates: it toggles every time an ON bulb enters, and holds steady when an OFF enters. The colour of the final wire tells you the parity.

Step 5 — The generator: choosing $P$ so the FULL word obeys a rule

WHAT. The sender adds one extra bulb $P$ (the parity bit) so that the full word $(d_{0}, \dots, d_{n - 1}, P)$ obeys an agreed rule. For even parity, the rule is "total ON count is even". The choice is: $P_{even} = X = d_{0} \oplus d_{1} \oplus \dots \oplus d_{n - 1}$

WHY exactly $P = X$ . Split the total ON count: $total = (data 1s) + P$ .

If the data already has an even count, then $X = 0$ , so $P = 0$ — we add nothing, total stays even. ✓
If the data has an odd count, then $X = 1$ , so $P = 1$ — we add one more ON, odd $+ 1$ = even. ✓

Both cases are captured by the single equation $P = X$ . It is not a coincidence; $P$ 's whole job is to cancel any oddness, and $X$ is precisely "how much oddness there is".

For odd parity, we want the total to be odd, so we need the opposite bit: $P_{odd} = \overline{X} (the bar means "flip it") = XNOR of all data bits$

PICTURE. The figure takes the XOR-tree output $X$ and drops it in as the last bulb $P$ . Watch the total ON count of the padded word — it lands on EVEN every single time.

Step 6 — The checker: the SAME tree, one input longer

WHAT. The receiver gets the padded word $(d_{0}, \dots, d_{n - 1}, P)$ and XORs everything, P included: $E = d_{0} \oplus d_{1} \oplus \dots \oplus d_{n - 1} \oplus P$ $E$ is the error signal — one output bulb.

WHY it's the same circuit. Compare with Step 4: the checker is just the generator's XOR tree with one more input wire (for $P$ ). $E$ is the parity of the whole received word.

In an even-parity system a correct word has even ON count, so its parity is $0$ : $E = 0$ means OK, $E = 1$ means error.
In an odd-parity system a correct word has odd count: $E = 1$ means OK, $E = 0$ means error.

Why it catches a flip. From Step 2, a single flip jumps the word to the other bucket, i.e. flips the whole-word parity, i.e. flips $E$ . So a good $E = 0$ becomes a screaming $E = 1$ .

PICTURE. The figure lays the generator and checker side by side. They are the same staircase; the checker just has the $P$ wire feeding one extra gate. A red lightning bolt flips a bulb in the middle and you can watch $E$ flip from $0$ to $1$ .

Step 7 — Every case, including the degenerate ones

WHAT. We must show the checker for all scenarios, not just the happy one.

PICTURE. The figure is a small table of received words with their $E$ and verdict, spanning the corners:

received word	ON count	$E$	even-parity verdict
$1010$ (correct)	2 (even)	$0$	OK ✓
$1110$ (1 flip)	3 (odd)	$1$	ERROR ✓
$1001$ (2 flips)	2 (even)	$0$	"OK" — MISSED ✗
$0000$ (all off)	0 (even)	$0$	OK ✓
$1111$ (all on)	4 (even)	$0$	OK ✓

WHY the cases matter:

All-zeros ( $0000$ ): zero is an even number, so $E = 0$ — a legitimately correct even word. The circuit does not choke on "nothing is on".
All-ones ( $1111$ ): four ON is even, $E = 0$ , OK. Both extremes behave.
Single flip: count changes by $\pm 1$ → odd → $E = 1$ → caught. Always.
Double flip (the blind spot): two flips change the count by an even amount ( $\pm 2$ or $0$ ), so the bucket is restored, $E = 0$ , and the error slips through. This is the fundamental limit: simple parity detects odd numbers of errors only, and it can never say which bulb moved — so it cannot correct. To locate/fix errors you need more redundancy: Hamming Codes, or stronger detectors like Checksums and CRC. See Error Detection and Correction for the ladder.

The one-picture summary

One tree of XOR gates does everything. Feed it the $n$ data bits and its output is $P$ (the generator). Feed it $n$ data bits plus $P$ and its output is $E$ (the checker). A flip crosses the even/odd bucket line and flips $E$ — caught. Two flips cross back — missed. That single figure is the entire topic.

Recall Feynman: retell the whole walkthrough

We have a row of light bulbs. All I care about is: is the number of glowing bulbs odd? Because if one bulb secretly flickers, that odd/even answer must change — one flip can only bump the count by one, and one bump always swaps odd↔even. To measure oddness I use XOR: an XOR gate glows when exactly one of its two inputs glows — that's "count is odd" for two bulbs. Chain them and it means "odd count" for any number of bulbs, because each ON bulb toggles the running answer. Before sending, I compute that answer and glue it on as a spare bulb $P$ , chosen so the total is even. My friend runs the very same XOR chain over everything I sent, including $P$ ; his answer $E$ should come out $0$ . If it comes out $1$ , a bulb flipped in transit — he doesn't know which, and if two flipped he's fooled, but for the common single glitch, he catches it every time. Same tree, two jobs: generate, then check.

Recall Quick self-test

Why XOR and not OR for parity? ::: OR says 1 for both "one ON" and "two ON", so it can't tell odd from even; XOR says 1 only for odd counts. A flip changes the ON count by how much, and why does that matter? ::: By $\pm 1$ , which always swaps even↔odd, so it always flips the parity signal $E$ . Even-parity checker: what does $E = 1$ mean? ::: An error — a correct even word gives $E = 0$ . Why is $0000$ reported OK in even parity? ::: Zero is even, so the parity of an all-off word is $0$ — a valid correct word. Why are two flips missed? ::: They change the count by an even amount, restoring the original bucket, so $E$ is unchanged.

Connections

XOR and XNOR gates — the single gate this entire page is built from.
Parity generators - checkers — the parent topic; this page is its visual derivation.
Combinational Circuits — the XOR tree has no memory; output depends only on current inputs.
Error Detection and Correction — where parity sits on the reliability ladder.
Hamming Codes — many parity bits, arranged to locate the flipped bit.
Checksums and CRC — stronger successors that catch more error patterns.
Adders & Multiplexers — other combinational blocks that lean on XOR.