Boolean Algebra

• The first step to logic: Boolean algebra, the math of True / False (1 / 0).
• Given input variables A, B, C, … compute outputs using logical operators:

Plus NAND, NOR, XNOR, …: the NOT of AND, OR, XOR.

Truth Tables

A truth table shows the output for every combination of inputs.

Any Inputs, Any Outputs

• A function can have any number of inputs and any number of outputs.
• It can be any mapping you like. Here are 3 inputs and 2 outputs:

Let’s Write a Truth Table for a Function

Suppose I Turn It Around…

Sum of Products: Works, but Ugly

We Did That by Intuition… but

• That was a somewhat intuitive approach to simplifying.
• This is math, so there are formal rules, just like “regular” algebra.

Boolean Function Simplification

• Double negation: !!A = A
• & and | are both commutative and associative.
• They distribute: A & (B | C) = (A & B) | (A & C)
• Absorption (subsumption): A | (A & B) = A

De Morgan’s Laws

Push a NOT inside the parentheses and flip & ↔︎ |:

\[\overline{A \cdot B} = \overline{A} + \overline{B} \qquad\qquad \overline{A + B} = \overline{A} \cdot \overline{B}\]

!(A & B) = !A | !B     !(A | B) = !A & !B

Check it yourself: build truth tables for both sides and compare.

Summary of the Boolean Axioms

Simplification Example

You Try This

You Try This: Simplify the First Part

You Try This: Finish It

Practice Question 1

Come up with a formula for this truth table. Simplify as much as possible.

Solution: Sum of Products

Step 1: Select rows where Output = 1

Write a product term for each row with output 1:

(!A & !B & C) |
(!A & B & C) |
(A & !B & !C) |
(A & B & !C)

Solution: Sum of Products

Step 2: Simplify the first two terms

Factor out !A & C:

(!A & !B & C) | (!A & B & C)
= (!A & C) & (!B | B)
= !A & C

Solution: Sum of Products

Step 3: Simplify the last two terms

Factor out A & !C:

(A & !B & !C) | (A & B & !C)
= (A & !C) & (!B | B)
= A & !C

Solution: Sum of Products

Step 4: Write the simplified answer

(!A & C) | (A & !C)

The variable B disappears because the output does not depend on its value.

Applying the Theory

• Lots of good theory: we can reason about complex Boolean expressions.
• But why is this useful?

Boolean Gates

Gates are electronic devices that implement simple Boolean functions: the building blocks of hardware.

Guide to Remembering Your Gates

Brief Interlude: Building an Inverter

A NOT gate takes just two transistors:

Boolean Functions, Gates, and Circuits

Circuits are networks of gates. Here is our answer from before, (!A & !C) | (A & C):

A Few More Words About Gates

• Gates have inputs and outputs.
• Never connect two outputs together: if one drives 1 and the other drives 0, bad things happen (your processor catches fire 🔥).

• If you leave an input unconnected, it behaves kind of randomly. Also not good, but not set-your-chip-on-fire bad.

Introducing the Multiplexer (“mux”)

Think of an HDMI switch 🎮📺: two game consoles (inputs A and B), one TV (the output), and a button (the selector S) that decides which console the TV shows.

Introducing the Multiplexer (“mux”)

Think of an HDMI switch 🎮📺: two game consoles (inputs A and B), one TV (the output), and a button (the selector S) that decides which console the TV shows.

Let’s Make a Useful Circuit: the 2-to-1 Mux

Circuit Example: 2-to-1 Mux in Gates

MUX(A, B, S) = (A & !S) | (B & S). It is so common that it gets its own symbol: a trapezoid.

Example: 4-to-1 Mux

Three 2-to-1 muxes make a 4-to-1 mux. The 2-bit selector picks one of 4 inputs: s₀ picks within each pair, s₁ picks the pair.

Arithmetic and Logical Operations

• What operations does the ISA need? add, sub, and, or, not, shifts, …
• How do we implement them in gates?
• Let’s start with the simplest: a 1-bit adder.

Designing a 1-bit Adder

• Which Boolean function gives the low bit (sum)? XOR
• Which Boolean function gives the high bit (carry)? AND

Remember Binary Addition?

Add the two bits plus the carry-in from the column to the right, and pass the carry-out to the left:

Designing a Full Adder

So we need to add three bits (a, b and the carry-in). The 2-bit result is the carry-out and the sum:

Turn it into an expression, simplify, build it from gates…

A 1-bit Full Adder

Sum = a ^ b ^ Cin    Cout = (a & b) | (Cin & (a ^ b))

Example: 4-bit Adder

Chain 4 full adders: each carry-out feeds the next adder’s carry-in (a ripple-carry adder).

Subtraction

• How do we perform integer subtraction? Recall why 2’s complement is a good idea: no new hardware!

\[X - Y = X + (-Y) = X + (\overline{Y} + 1)\]

Example: Adder/Subtractor

Overflow

• Unsigned overflow: look at the final carry-out C_out (for addition, C_out = 1 means the result didn’t fit).
• Signed overflow happens when:
  • adding two positives gives a negative, or
  • adding two negatives gives a positive.
• Detect it at the most significant bit: overflow if carry-in ≠ carry-out, which is a single XOR gate!

Add/Subtract With Overflow Detection

ALU Slice

One bit of an Arithmetic Logic Unit: compute every operation in parallel, then use a mux (controlled by F) to pick the result.

The ALU

Chain the slices like the adder. Two extra outputs are cheap to add: overflow (XOR of the top carries) and non-zero? (OR of all result bits).

Alternate ALU Design

Abstraction: The ALU

Another Operation We Might Want: Shift

• Remember << and >>? How would we implement them?
• Suppose we have an 8-bit number \(b_7 b_6 b_5 b_4 b_3 b_2 b_1 b_0\)…
• …and want to shift it left by a 3-bit amount \(s_2 s_1 s_0\) (0–7 places).

Building a Bit Shifter: Shift by One

A simpler problem: a shift-by-one circuit. Eight 2-to-1 muxes, all controlled by the same bit s₀:

Building a Bit Shifter: Shift by Two

The same idea, but each mux’s “1” input comes from two rows below (controlled by s₁):

Building a Bit Shifter: Shift by Four

And from four rows below (controlled by s₂):

Now Shift by a 3-bit Number

Put the three stages in a row. Any shift 0–7 is a sum of 4, 2 and 1, so s₂ s₁ s₀ is just the shift amount in binary! Try 000, then 011 (shift by 3).

Summary

• Boolean algebra and functions: truth tables, sum of products, simplification, De Morgan’s laws
• Logic gates: AND, OR, NOT, XOR, NAND, NOR, XNOR, and how they’re built from transistors
• Multiplexers: select one of several inputs
• Adders: half adder → full adder → ripple-carry adder → adder/subtractor with overflow detection
• Arithmetic Logic Unit (ALU): compute every operation, mux out the one you want
• Bit shifting: a barrel shifter made of mux stages