Implementing Boolean Functions with Multiplexers

Recommended resources

The freely available resources this lesson will direct you to.

Hello! In the previous lesson, you implemented a Boolean function with gates and checked that each circuit matched its truth table. A multiplexer offers another implementation: instead of building the expression term by term, you use some variables to select an input and wire that input to the value the function should produce.

We’ll start with the same three-variable function you already know, implement it with two different MUX sizes, and then use the supplied circuit image to see how the method extends to four variables.

A MUX selects one data input

A multiplexer, or MUX, has data inputs, select inputs, and one output. A 4-to-1 MUX has four data inputs $D_{0}$ through $D_{3}$ and two select inputs $S_{1}, S_{0}$ . Its output is whichever data input the binary select value names:

$S_{1} S_{0}$	Output
00	$D_{0}$
01	$D_{1}$
10	$D_{2}$
11	$D_{3}$

For example, when $S_{1} S_{0} = 10$ , the output equals $D_{2}$ . If $D_{2}$ is connected to logic 1, the output is 1 for that selection; if it is connected to another signal, the output follows that signal. This is the key design question: for each select combination, what must the selected data input produce?

Watch the first portion of Multiplexer Explained | Implementation of Boolean function using Multiplexer from ALL ABOUT ELECTRONICS. It demonstrates the direct truth-table method with an 8-to-1 MUX. The video calls three select lines necessary for its direct three-variable construction; we’ll shortly see a construction using fewer select lines.

Multiplexer Explained | Implementation of Boolean function using Multiplexer

Watch Multiplexer Explained | Implementation of Boolean function using Multiplexer from ALL ABOUT ELECTRONICS to see how select combinations correspond to truth-table rows.

Watch direct mapping. Focus on which variable goes to each select pin and why data inputs corresponding to output-1 rows are tied to logic 1.

Implement a truth table directly

Our running function is

Y = A B + B C .

From the previous lesson, its output is 1 for $A B C = 000, 001, 011, 111$ , and 0 for the other four input combinations. An 8-to-1 MUX has three select lines, so assign $S_{2} = A$ , $S_{1} = B$ , and $S_{0} = C$ . The binary value of $A B C$ now names the selected data input: $A B C = 011$ , for instance, selects $D_{3}$ .

$A B C$	Selected input	Required $Y$	Connect input to
000	$D_{0}$	1	1
001	$D_{1}$	1	1
010	$D_{2}$	0	0
011	$D_{3}$	1	1
100	$D_{4}$	0	0
101	$D_{5}$	0	0
110	$D_{6}$	0	0
111	$D_{7}$	1	1

Thus $D_{0}, D_{1}, D_{3}, D_{7}$ are tied to logic 1; the rest are tied to logic 0. The MUX output is $Y$ . No K-map minimization is needed for this method: once the select order is fixed, the truth table specifies every data connection.

Pin order matters. If you instead put $B$ on $S_{2}$ , the table above would no longer describe which input each $A B C$ combination selects. Write down the select-to-variable assignment before assigning the data inputs.

Use fewer select lines by letting a data input vary

The direct implementation uses all three variables as selectors. But a data pin does not have to be tied to a constant: it can be connected to a function of an input variable. For a three-variable function, choose two variables as the select signals of a 4-to-1 MUX and determine what each data input must do as the third variable changes.

Continue the video for a worked example of this paired-row method. Its function differs from ours; concentrate on how two truth-table rows determine each data connection.

Multiplexer Explained | Implementation of Boolean function using Multiplexer

Continue the same video to see how a four-input MUX can implement a three-variable function.

Watch paired rows. For each fixed pair of select values, follow the two output values as the remaining variable changes. Notice the four possible data connections: 0, 1, the remaining variable, or its complement.

For our function, set $S_{1} = A$ and $S_{0} = B$ , leaving $C$ off the select pins. Hold $A B$ fixed and inspect the two outputs obtained when $C = 0$ and $C = 1$ :

$A B$	Output at $C = 0$	Output at $C = 1$	Data input
00	1	1	$D_{0} = 1$
01	0	1	$D_{1} = C$
10	0	0	$D_{2} = 0$
11	0	1	$D_{3} = C$

Why does the pair $0, 1$ mean $C$ ? Because a wire carrying $C$ is 0 when $C = 0$ and 1 when $C = 1$ . In general, a pair of outputs $(0, 0)$ calls for logic 0, $(1, 1)$ for logic 1, $(0, 1)$ for the remaining variable, and $(1, 0)$ for its complement.

The complete circuit therefore connects $A, B$ to $S_{1}, S_{0}$ , connects $1, C, 0, C$ to $D_{0}, D_{1}, D_{2}, D_{3}$ , respectively, and takes $Y$ from the MUX output. For a quick check, $A B C = 011$ makes $A B = 01$ , so the MUX selects $D_{1} = C = 1$ . At $A B C = 010$ , it selects the same pin, but $C = 0$ , giving the required output 0.

This implementation needs a smaller MUX than the direct one because its data pins carry some of the function’s behavior rather than only constants.

Read a four-variable implementation

The supplied image applies exactly that paired-row idea to four variables with an 8-to-1 MUX. Here $B, C, D$ drive $S_{2}, S_{1}, S_{0}$ , while $A$ is the remaining variable. Each data input corresponds to a fixed $B C D$ value and must work for both $A = 0$ and $A = 1$ .

The left table pairs the function outputs for $A=0$ and $A=1$ at each fixed $BCD$ value; the right circuit connects the resulting constants, $A$, and $\overline A$ to the eight MUX data inputs.

The circled entries in the image are the output-1 cases. Reading each column from its upper row ( $A = 0$ ) to its lower row ( $A = 1$ ) gives the wiring plan:

$B C D$	Output pair for $A = 0, 1$	MUX connection
000	$0, 0$	$D_{0} = 0$
001	$1, 0$	$D_{1} = A$
010	$0, 0$	$D_{2} = 0$
011	$1, 1$	$D_{3} = 1$
100	$1, 0$	$D_{4} = A$
101	$1, 0$	$D_{5} = A$
110	$1, 0$	$D_{6} = A$
111	$0, 1$	$D_{7} = A$

For instance, $B C D = 001$ selects $D_{1}$ . The required output is 1 when $A = 0$ and 0 when $A = 1$ , so $D_{1}$ must carry $A$ . The circuit generates that signal with an inverter and shares it among several data pins. By contrast, $B C D = 011$ selects $D_{3} = 1$ regardless of $A$ .

The rule scales: with $k$ select variables, a MUX has $2^{k}$ data inputs. If one variable remains, compare its two truth-table rows for each select combination and connect the corresponding data pin to $0$ , $1$ , that variable, or its complement.

Check the wiring, not just the plan

A MUX implementation is correct only if its select-pin order and every data-pin connection reproduce the original function. Check a circuit by taking an input combination, finding the selected pin, and evaluating the signal connected to it. In the image, $A B C D = 1101$ gives $B C D = 101$ , selecting $D_{5} = A = 0$ ; the output is therefore 0. For $A B C D = 1111$ , $B C D = 111$ selects $D_{7} = A = 1$ .

Two practical details prevent otherwise sound designs from failing. First, a data input specified as 0 or 1 must be driven to a defined logic level, not left unconnected. Second, if a particular MUX has an enable input, it must be held in its enabled state; the required level depends on that device’s interface.

A smaller MUX is not automatically a cheaper or faster implementation: supplying $A$ , for example, may require an inverter. At this stage, the priority is a complete, equivalent wiring plan. Later lessons will examine circuit delay and implementation trade-offs.

Key takeaways

A MUX realizes a Boolean function by selecting a data input whose value matches the required output. The direct method uses every function variable as a select signal and ties data pins to truth-table values. A smaller MUX uses fewer select signals; for each fixed select combination, compare the outputs as the remaining variable changes and connect the data pin to $0$ , $1$ , the variable, or its complement. Always verify the result using the actual select order and data connections.

Next, you’ll design an adder or subtractor from a bit-level specification, putting these combinational-logic skills to work on arithmetic.