Visual walkthrough — Demultiplexers

We assume nothing except that you know a wire can carry a $0$ (off / low / no signal) or a $1$ (on / high / signal present). Everything else — AND, NOT, "select", "minterm" — we grow from there, on a picture.

---

Step 1 — Draw the problem before drawing any circuit

WHAT. We have one wire coming in, call it $D$ (for Data). We have several wires going out. We want the signal on $D$ to appear on exactly one of the output wires, and we want a separate small set of "control" wires to decide which one.

WHY. You cannot build a machine until you know precisely what it must do. So before any logic gate, we draw the shape of the task: one road splitting into many, with a switch box in the middle.

PICTURE. Look at the figure. The orange wire on the left is $D$. The plum wire coming from below is the select line $S$ — the "number card" that picks a destination. The two teal wires on the right are the outputs $Y_0$ and $Y_1$. The box in the middle is the thing we must design.

---

Step 2 — Write the contract as a truth table

WHAT. We list, for every possible combination of $S$ and $D$, what each output must be. This table is a promise: whatever circuit we build must reproduce it exactly.

WHY. Logic has only a handful of inputs, so we can simply enumerate all of them and state the wanted result. There is no guesswork after this — the table is the full specification.

With one select wire $S$ and one data wire $D$, there are only $2\times 2=4$ input combinations. Here is the contract:

$S$	$D$	$Y_0$	$Y_1$
0	0	0	0
0	1	1	0
1	0	0	0
1	1	0	1

PICTURE. In the figure, each row of the table is drawn as the actual switch position: when $S=0$ the switch points up to $Y_0$; when $S=1$ it points down to $Y_1$. The bold 1s in the table are exactly the two rows where a signal actually gets through.

---

Step 3 — Turn "and" into a gate, and "not" into a bubble

WHAT. We introduce the two logic building blocks the table just demanded.

WHY these two tools and not others? The phrase "$S=0$ and $D=1$" contains two ideas:

• AND — an output that is $1$ only when both its inputs are $1$. This is the only gate that says "both conditions must hold at once", which is exactly what routing needs (the right door and real data).
• NOT — flips $0\leftrightarrow 1$. We need it because $Y_0$ fires when $S$ is $0$, but an AND gate wants a $1$ to open. So we feed it "$S$ flipped", written $\overline{S}$ (read "S-bar" or "not S").

PICTURE. The figure shows a truth-table strip for AND (only the bottom-right cell is $1$) and the NOT bubble turning $0$ into $1$ and $1$ into $0$.

---

Step 4 — Read each output straight off the table

WHAT. We convert the two "only when..." sentences from Step 2 into equations using the AND and NOT we just built.

WHY. Each output is $1$ in exactly one table row. That row says "$D=1$ combined with a specific value of $S$". Writing that as an AND of the right pieces guarantees the equation matches the table row-for-row — no gap, no extra case.

$$Y_0=\underset{\begin{array}{c}\text{true only}\\ \text{when }S=0\end{array}}{\underbrace{\overline{S}}}\cdot \underset{\begin{array}{c}\text{the actual}\\ \text{data bit}\end{array}}{\underbrace{D}}{Y}_1=\underset{\begin{array}{c}\text{true only}\\ \text{when }S=1\end{array}}{\underbrace{S}}\cdot \underset{\begin{array}{c}\text{the actual}\\ \text{data bit}\end{array}}{\underbrace{D}}$$

Read $Y_0=\overline{S}D$ as: "$Y_0$ is $1$ when the door is selected ($S=0$, so $\overline{S}=1$) and the data is $1$." If either fails, the AND gives $0$ — the output stays dark. Same story for $Y_1$ with $S$ instead of $\overline{S}$.

PICTURE. The figure draws the full 1-to-2 DEMUX: $D$ splits into two branches; the top branch AND-gates with $\overline{S}$ (note the bubble on $S$) to make $Y_0$; the bottom branch AND-gates with $S$ to make $Y_1$.

---

Step 5 — Check the equations against the table (all four rows)

WHAT. We plug every input combination into $Y_0=\overline{S}D$ and $Y_1=SD$ and confirm they reproduce Step 2's contract. No row may disagree.

WHY. An equation that matches some rows is a bug waiting to happen. We test all four so no reader ever meets a case we didn't cover.

$S$	$D$	$\overline{S}$	$Y_0=\overline{S}D$	$Y_1=SD$
0	0	1	$1\cdot 0=0$	$0\cdot 0=0$
0	1	1	$1\cdot 1=1$	$0\cdot 1=0$
1	0	0	$0\cdot 0=0$	$1\cdot 0=0$
1	1	0	$0\cdot 1=0$	$1\cdot 1=1$

Every row matches Step 2. ✅

PICTURE. The figure lays the four cases side by side as glowing/dim wires so you can see which output lights up in each case — including the two rows where nothing lights up.

---

Step 6 — Grow it to $2^n$ outputs: the minterm idea

WHAT. With more select wires we get more doors. For $n$ select lines $S_{n-1}\dots S_0$ we get $2^n$ outputs, and each output uses its own AND-of-selects term called a minterm.

WHY. With $n$ select bits there are $2^n$ possible binary codes. We want output $Y_k$ to fire for exactly one code — the one whose binary value is $k$. The term that is $1$ for one code and $0$ for all others is the AND of every select variable, each barred where that code has a $0$. That term is the minterm $m_k$.

For $n=2$ (selects $S_1{S}_0$, with $S_1$ the more significant bit):

$$\begin{array}{llll}{m}_0=\overline{S_1}\overline{S_0}& m_1=\overline{S_1}{S}_0& m_2=S_1\overline{S_0}& m_3=S_1{S}_0\\ Y_0=D{m}_0& Y_1=D{m}_1& Y_2=D{m}_2& Y_3=D{m}_3\end{array}$$

Term-by-term for $m_2=S_1\overline{S_0}$: it wants $S_1=1$ and $S_0=0$, i.e. the code $10_2=2$. So $m_2$ is $1$ only when the selects spell $2$ — and then $Y_2=D\cdot 1=D$. Every other minterm is $0$ for that code, so every other output is dark.

PICTURE. The figure shows a 1-to-4 DEMUX: $D$ fanning into four AND gates, each fed by a different minterm decode of $S_1{S}_0$. The selects $10$ are set, so only the $Y_2$ gate opens.

---

Step 7 — The degenerate cases (never skip these)

WHAT. We check the boundary situations: $D=0$, and confirm all non-selected outputs are hard $0$ (not "floating", not "remembering").

WHY. A tool you trust must behave predictably at its edges. Two edge behaviours trip people up (see the parent's Common Mistakes), so we draw them explicitly.

Case A — $D=0$. Then $Y_k=0\cdot m_k=0$ for every $k$, no matter what the selects say. The chosen door is still chosen, but nothing flows.

Case B — a non-selected output. For any $k$ that is not the current select code, $m_k=0$, so $Y_k=D\cdot 0=0$. It is driven to $0$ by the AND gate — it does not float and does not keep an old value. Only the one selected output copies $D$.

PICTURE. The figure contrasts two 1-to-4 DEMUX snapshots: left with $D=1$ (one door glows), right with $D=0$ (all doors dark though the same door is "selected").

---

The one-picture summary

WHAT. One figure that compresses the whole journey: contract → AND/NOT gates → minterms → $Y_k=D{m}_k$, drawn as the full 1-to-4 DEMUX with a worked case ($D=1$, $S_1{S}_0=10\Rightarrow Y_2=1$).

Recall Feynman retelling — the whole walkthrough in plain words

We started with a picture: one road ($D$) that must split into several roads, with a "number card" ($S$) deciding which. We wrote down every case in a small table — our unbreakable promise. Reading the table out loud, the word "and" kept appearing, so we invented two tiny machines: an AND gate (open only when both inputs are on) and a NOT bubble (flips a wire). We used them to write each output as "the data, AND-ed with the condition that this door is the chosen one" — that condition is the minterm of the select lines. We checked all four rows and they matched perfectly, including the two quiet rows where no data flows. Then we grew it: $n$ select wires spell one of $2^n$ codes, each code lights exactly one minterm, and $Y_k=D\cdot m_k$. Finally we poked the edges: turn the data off and every door goes dark; every door except the chosen one is firmly held at $0$ by its own AND gate. That's the whole demultiplexer — a decoder that gates the data into whichever door its number card selects.

Recall Quick self-test

Why does $Y_0$ use $\overline{S}$ and not $S$? ::: $Y_0$ must fire when $S=0$, but AND opens on a $1$, so we flip $S$ to $\overline{S}$ which is $1$ when $S=0$. For $n=3$ selects, how many outputs and how many minterms? ::: $2^3=8$ outputs, one minterm each. With $S_1{S}_0=10$ and $D=1$, which output is high in a 1-to-4 DEMUX? ::: $Y_2$ (binary $10=2$), all others $0$. If $D=0$, what are all outputs? ::: All $0$, whatever the selects are.

Connections

• Demultiplexers — the parent topic this walkthrough derives.
• Decoders — the minterm block alone; tie $D=1$ and the DEMUX becomes one.
• Multiplexers — the mirror operation, many-in one-out.
• Minterms and SOP — where the $m_k$ terms come from.
• Encoders — related decode/encode family.
• Memory Addressing — selecting one memory row is exactly this routing.
• Bus Systems — one bus line fanned to many destinations.