Decoders (2 - 4, 3 - 8): Visual walkthrough — Hardware deep dive

Before any symbol appears, let us agree what our raw material is.

Step 1 — Two switches make four possible "codes"

WHAT. We take two bits and give them names. Call the left one $A_{1}$ and the right one $A_{0}$ . The subscript is just a label so we can talk about each switch separately — nothing more yet.

WHY. A single switch only has 2 states, which cannot pick between 4 rooms. Two switches together have more room to breathe: each can be $0$ or $1$ independently, so together they can be in $2 \times 2 = 4$ distinct settings. Four settings is exactly what we need to address four output lines.

PICTURE. Look at the four rows on the left. Each row is one combination of the two switches: $00, 01, 10, 11$ . There are no others — you cannot invent a fifth combination of two on/off switches.

We now have a way to turn any of the four codes into a plain decimal number $0, 1, 2, 3$ . That number is the whole point: it names which output we want.

Step 2 — What we WANT: one lamp, never two

WHAT. We line up four output lamps, labelled $D_{0}, D_{1}, D_{2}, D_{3}$ . The $D$ stands for "decoder output"; the subscript is the lamp's number. Our goal: when the switches spell the number $k$ , lamp $D_{k}$ lights and the other three stay dark.

WHY. Downstream hardware (a memory row, a display segment) needs its own private wire that is high only for it. A binary code is compact but shared; we must fan it out to one dedicated wire per item. That "exactly one wire on" behaviour has a name.

PICTURE. In the figure, the switches read $10$ (value $2$ ), and only $D_{2}$ glows. This is one-hot: out of all the outputs, exactly one is "hot" (on).

Step 3 — The truth table is the specification

WHAT. We write down, for every one of the four input rows, what all four lamps must do. This table is the definition of our circuit — it leaves nothing to guess.

WHY. A circuit is fully determined once you say its output for every possible input. With only 4 input rows, we can list them all — no case is skipped. Notice the shape of the answer before we do any algebra.

PICTURE. The highlighted diagonal of single $1$ 's is the key visual: each output column contains exactly one $1$ . That single- $1$ pattern is our clue for Step 4.

$A_{1}$	$A_{0}$	value	$D_{0}$	$D_{1}$	$D_{2}$	$D_{3}$
0	0	0	1	0	0	0
0	1	1	0	1	0	0
1	0	2	0	0	1	0
1	1	3	0	0	0	1

Step 4 — Introducing NOT and AND (the only two tools we need)

Before we can write a lamp's equation, we must earn two operations. We choose these two on purpose — here is the "why this tool" for each.

WHY NOT. Lamp $D_{0}$ must fire when $A_{1} = 0$ AND $A_{0} = 0$ . But our building block "AND" (next paragraph) only fires on $1$ 's, not on $0$ 's. So we need a way to say "is this switch OFF?" as a fresh signal that is $1$ when the switch is $0$ . That flip is the job of NOT, written with a bar: $\overline{A_{0}}$ reads "NOT $A_{0}$ ".

WHY AND. Each lamp must check several conditions at once (" $A_{1}$ is this AND $A_{0}$ is that"). The operation that is $1$ only when all its inputs are $1$ is AND, written as a dot: $A_{1} \cdot A_{0}$ , or just $A_{1} A_{0}$ .

PICTURE. The top panel shows NOT as a mirror: input $0$ becomes $1$ , input $1$ becomes $0$ . The bottom panel shows AND as a strict gatekeeper: its bulb lights only when both wires are on.

Step 5 — Turning one table row into one equation (a minterm)

WHAT. Take row $D_{0}$ : it is high only when $A_{1} = 0$ and $A_{0} = 0$ . Translate each condition into our atoms and AND them.

WHY. We want a single expression that is $1$ in exactly one row and $0$ everywhere else — matching the single- $1$ column we saw in Step 3. " $A_{1}$ is $0$ " becomes $\overline{A_{1}}$ (which is $1$ when $A_{1} = 0$ ). " $A_{0}$ is $0$ " becomes $\overline{A_{0}}$ . ANDing them gives something that is $1$ only when both are true — i.e. only in row $0$ .

PICTURE. The figure feeds $A_{1} = 0, A_{0} = 0$ through two NOT gates (both become $1$ ) into an AND gate whose output goes high — lamp $D_{0}$ lights. Change either switch and one input to the AND drops to $0$ , so the lamp dies.

$D_{0} = demands A_{1} = 0 \overline{A_{1}} \cdot demands A_{0} = 0 \overline{A_{0}} \Rightarrow D_{0} = 1 only at row 00$

Step 6 — Do it for all four lamps

WHAT. Repeat Step 5 mechanically for each row. For each lamp, bar the switches that must be $0$ , leave plain the switches that must be $1$ , and AND them.

WHY. Every column in the truth table had a single $1$ , so every column is a minterm. There is nothing to simplify — no clever algebra, no K-map — because a single- $1$ column is already the simplest form. This is the beautiful thing about decoders: the table reads off directly as gates.

PICTURE. All four minterm circuits sit side by side. Trace the bars: a bar sits over $A_{1}$ exactly where that row needs $A_{1} = 0$ , and over $A_{0}$ exactly where that row needs $A_{0} = 0$ .

These are exactly the four equations the parent note stated — but now you built them, symbol by symbol.

Step 7 — The degenerate case: the master switch (Enable)

WHAT. Add one more input $E$ ("Enable"). Redefine every lamp as its minterm ANDed with $E$ : $D_{k} = E \cdot (minterm)$ .

WHY. We must cover the case where the whole chip should be silent — for instance while we build bigger decoders, or use it as a router. When $E = 0$ , the AND forces every output to $0$ no matter what the switches say (because anything AND $0$ is $0$ ). When $E = 1$ , the AND passes the minterm through unchanged (anything AND $1$ is itself). So $E$ is a clean on/off master.

PICTURE. Two panels. Left: $E = 0$ — all four lamps dark even though the switches read $10$ . Right: $E = 1$ , same switches — only $D_{2}$ glows, normal behaviour restored.

The one-picture summary

This final figure compresses all seven steps: switches → decimal value → the single matching minterm → one hot lamp, with the Enable master gate riding on top.

Recall Feynman: the whole walkthrough in plain words

We began with two light switches, each just on or off. Two switches can be set four ways: 00, 01, 10, 11 — and we read each setting as a plain number 0, 1, 2, 3 by giving the left switch double the weight of the right. Then we said what we WANT: four lamps, and only the lamp whose number matches the switches should glow. We wrote that wish as a table — and noticed each lamp's column had exactly one "1". To turn a "1" into wires, we earned two tiny tools: NOT (a mirror that flips a switch) and AND (a strict gatekeeper that lights only when everything feeding it is on). For each lamp we barred the switches that had to be off and left plain the ones that had to be on, then ANDed them — that combination is called a minterm, and it lights for exactly one setting. Doing that four times gave the four decoder equations directly, with no clever simplification needed. Finally we bolted on a master switch, Enable: AND it into every lamp so that flipping it off darkens the whole board at once. That is a 2:4 decoder — two switches in, one hot wire out, master power optional.

Connections

Minterms and Maxterms — each lamp's equation is a minterm; this page builds one from scratch.
Sum of Products (SOP) — OR a chosen subset of these outputs to realize any function.
Demultiplexers — reuse the Enable pin of Step 7 as a data line to route one bit.
Multiplexers — the complementary "many-to-one" block.
Encoders — the exact inverse: one-hot in, binary out.
Memory Address Decoding — where the one-hot lines pick physical RAM rows.
7-Segment Display Driver — decoding a number into lit segments.