Encoders and priority encoders: Visual walkthrough

Step 1 — What are the wires? (the one-hot picture)

WHAT. We have four input wires named $I_{0}, I_{1}, I_{2}, I_{3}$ . Each wire is either HIGH (carrying a 1, "on") or LOW (carrying a 0, "off"). We have two output wires $Y_{1}$ and $Y_{0}$ .

WHY start here. Before any algebra, you must see what a signal is: a wire is just a road that is either lit or dark. The word one-hot means "exactly one wire is lit at a time" — like a row of light bulbs where only one glows.

PICTURE. Four bulbs in a row. Only $I_{2}$ glows (red). The job of the box is to shout its number — the label $2$ — on the output wires.

Step 2 — Turn the wanted behaviour into a table

WHAT. List every "which wire is lit" case and the binary number we want out. This list is called a truth table — it just records, row by row, "given these inputs, what output do we demand?"

WHY. We cannot design a circuit until we have pinned down its goal exactly. The table is the goal, frozen. Nothing is derived yet; we are only writing our wish.

Lit wire	its index $j$	$Y_{1}$	$Y_{0}$
$I_{0}$	0	0	0
$I_{1}$	1	0	1
$I_{2}$	2	1	0
$I_{3}$	3	1	1

PICTURE. The same four bulbs, but now each row is drawn with its wanted two-bit answer glued to the right. Notice the pattern in the coloured column.

Step 3 — Read each output column down the table

WHAT. Instead of reading the table left-to-right (per row), read it top-to-bottom, one output column at a time. Ask: "For which lit wires is this column a 1?"

WHY. Each output bit is a separate little machine. If I know exactly which inputs must switch a bit ON, I can wire that bit directly — I do not need to think about the other bit at all. Splitting the problem this way is the whole trick.

Reading the $Y_{0}$ column down: it is $1$ for $I_{1}$ and $I_{3}$ (the odd indices — the ones whose binary form ends in 1). Reading the $Y_{1}$ column down: it is $1$ for $I_{2}$ and $I_{3}$ (the indices $\geq 2$ — whose binary form starts with 1).

PICTURE. The table with two coloured highlight bands: the $Y_{0}$ -band touches rows $I_{1}, I_{3}$ ; the $Y_{1}$ -band touches rows $I_{2}, I_{3}$ .

Step 4 — Wire it with OR gates (the plain encoder)

WHAT. " $Y_{0}$ is 1 when $I_{1}$ is lit or $I_{3}$ is lit" is exactly what an OR gate does: an OR gate outputs 1 if any of its inputs is 1.

WHY OR and not AND? We want "either of these fires it." AND would demand both at once — but our rule is one-hot, only one wire is ever lit, so "both" never happens and AND would output 0 forever. OR is the tool that matches the word "or" in our reading of Step 3.

PICTURE. Two OR gates. Wire $I_{1}$ and $I_{3}$ feed the top gate ( $Y_{0}$ ); $I_{2}$ and $I_{3}$ feed the bottom gate ( $Y_{1}$ ). The shared wire $I_{3}$ (red) fans out to both.

Step 5 — Watch it break: two wires lit at once

WHAT. Feed in $I_{1} = 1$ and $I_{2} = 1$ together. Trace the OR gates: $Y_{0} = I_{1} + I_{3} = 1 + 0 = 1, Y_{1} = I_{2} + I_{3} = 1 + 0 = 1$ Output $= 11 = 3$ .

WHY it's wrong. We lit wires 1 and 2, but the box shouted 3 — a number we never pressed! The OR gates each did their honest local job, but they merged the bit from index 1 into the bit from index 2, manufacturing a code belonging to neither.

PICTURE. Both $I_{1}$ and $I_{2}$ glowing; the red arrows show bit-from-1 and bit-from-2 colliding at the output to make the fake "3".

Step 6 — Fix #1: the Valid bit $V$

WHAT. Add one more output, $V$ , that is 1 iff at least one input is lit: $V = OR of every input I_{0} + I_{1} + I_{2} + I_{3}$

WHY. This cures failure #2. When nothing is pressed, every $I_{j} = 0$ , so $V = 0$ — a flag saying "ignore the $Y$ wires, the room is empty." When $I_{0}$ alone is pressed, $V = 1$ and $Y_{1} Y_{0} = 00$ genuinely means index 0. The ambiguity is gone: $00$ with $V = 0$ = nothing; $00$ with $V = 1$ = index 0.

PICTURE. A single big OR gate eating all four inputs and lighting the $V$ lamp; a side panel contrasts " $00, V = 0$ = empty" vs " $00, V = 1$ = bell 0".

Step 7 — Fix #2: install priority (the tie-breaker)

WHAT. Choose a ranking: $I_{3} > I_{2} > I_{1} > I_{0}$ . Rule: when several are lit, report the highest-ranked one and ignore the rest. The $\times$ below means don't-care (this input may be 0 or 1, it doesn't change the answer because a higher input already decided it).

$I_{3}$	$I_{2}$	$I_{1}$	$I_{0}$	$Y_{1}$	$Y_{0}$	$V$
0	0	0	0	$\times$	$\times$	0
0	0	0	1	0	0	1
0	0	1	$\times$	0	1	1
0	1	$\times$	$\times$	1	0	1
1	$\times$	$\times$	$\times$	1	1	1

WHY. The $\times$ columns are the visible proof of priority: once $I_{3} = 1$ , we don't care what $I_{2}, I_{1}, I_{0}$ do — the winner is locked. This deterministic rule replaces the garbage of Step 5.

PICTURE. A staircase: from the top row down, the "already decided" cells collapse into don't-cares. The lit winner in each row is red.

Step 8 — Derive the priority equations, term by term

WHAT & WHY, bit by bit.

$Y_{1}$ must be 1 for indices 2 and 3. Both winners ( $I_{2}$ alone, or $I_{3}$ ) demand $Y_{1} = 1$ , and $I_{3}$ outranking $I_{2}$ still gives $Y_{1} = 1$ — so no suppression is needed: $Y_{1} = index 2 wins I_{2} + index 3 wins I_{3}$

$Y_{0}$ must be 1 for indices 1 and 3. But $I_{1}$ is dangerous: if $I_{2}$ (a higher rank) is also lit, index 2 wins and demands $Y_{0} = 0$ . So $I_{1}$ may only speak when $I_{2}$ is silent. We gate it with $\overline{I_{2}}$ ("NOT $I_{2}$ ", meaning $I_{2}$ is off): $Y_{0} = index 3 always forces Y_{0} = 1 I_{3} + index 1 counts only if I_{2} is off I_{1} \overline{I_{2}}$ Here writing two symbols side by side, $I_{1} \overline{I_{2}}$ , means AND: both must be true — $I_{1}$ lit and $I_{2}$ dark.

Why does $I_{3}$ not need a guard? Nothing outranks $I_{3}$ , and index 3 is odd so it wants $Y_{0} = 1$ anyway — it can never be wrong.

PICTURE. The $Y_{0}$ gate redrawn: $I_{1}$ passes through an AND with the inverted $I_{2}$ (a bubble on the wire = NOT), then ORs with $I_{3}$ . The red bubble is the whole idea.

Step 9 — Re-run the broken case (does the fix hold?)

WHAT. Same trouble input as Step 5: $I_{1} = 1, I_{2} = 1$ , others 0. Now through the priority equations:

$V = 0 + 1 + 1 + 0 = 1$ — someone's here.
$Y_{1} = I_{2} + I_{3} = 1 + 0 = 1$ .
$Y_{0} = I_{3} + I_{1} \overline{I_{2}} = 0 + (1) (\overline{1}) = 0 + (1) (0) = 0$ .
Output $= 10 = 2$ . ✅

WHY it now works. $I_{2}$ outranks $I_{1}$ ; the $\overline{I_{2}}$ bubble switched OFF $I_{1}$ 's contribution, so index 2 (the higher wire) cleanly wins. The garbage "3" is impossible.

PICTURE. Side-by-side: left = plain encoder shouting the fake "3"; right = priority encoder shouting the correct "2", with the $\overline{I_{2}}$ bubble crossing out $I_{1}$ 's influence (red).

The one-picture summary

Everything compressed: four inputs → an OR-net (plain encoder) → break under collisions → add $V$ (validity) and $\overline{I_{2}}$ suppression (priority) → clean binary code out.

Recall Feynman: the whole walkthrough in plain words

Picture four doorbells, numbered 0 to 3, and a little box that must shout the number of whichever bell rang, using just two on/off wires (binary). We first read our wish as a table, then noticed each output wire is simply an OR — "light this bit if bell 1 or bell 3 rang." That's the plain encoder. But two kids can ring at once. The plain box merges their bits and shouts a bell nobody pressed. Two fixes: (1) a Valid lamp that only glows when someone actually rang — so "0-0 and dark" means empty, "0-0 and lit" means bell 0; and (2) a politeness rule — always report the biggest bell, silencing smaller ones. In wiring, that silencing is a little NOT bubble: bell 1 only gets a voice when bell 2 is quiet. Re-run the two-kid case and the box now correctly names the bigger bell. Done.

Connections

Decoders — run this whole picture backwards.
Multiplexers — same OR-of-selected-lines flavour.
Interrupt controllers — where the priority rule earns its keep.
Boolean algebra simplification — why $I_{1} \overline{I_{2}}$ is the minimal guard.
Karnaugh maps — the don't-cares of Step 7 fill K-map cells.
Combinational circuits — parent family; no memory, output = pure function of inputs.