CSE 311 Lecture 04:
Boolean Algebra

Topics

Equivalence and proofs

A brief review of Lecture 03.

Boolean algebra

A notation for combinational circuits.

Simplification and proofs

Optimizing circuits and proving theorems.

Equivalence via truth tables and proofs

$A \equiv B$ is an assertion that two propositions $A$ and $B$ have the same truth values in all possible cases.

$A \equiv B$ and $\underbrace{(A \leftrightarrow B) \equiv \mathsf{T}}_\mathsf{tautology}$ have the same meaning.

Checking equivalence has many real-world applications.

Verification, optimization, and more!

There are two ways to check equivalence of propositional formulas.

Brute-force: compare their truth tables.

Proof-based: apply equivalences to transform one into the other.

Recall the relationship between logic and circuits …

Digital circuits implement propositional logic:

• $\mathsf{T}$ corresponds to 1 or high voltage.
• $\mathsf{F}$ corresponds to 0 or low voltage.

Digital circuits are functions that

• take values 0/1 as inputs and produce 0/1 as output;
• $\mathit{out} = F(\mathit{input})$, where $F$ is built out of wires and gates; and
• every bit of output is computed from some bits of the input.

We call these types of digital circuits combinational logic circuits. There are other kinds of digital circuits (called sequential circuits) but we’ll focus on combinational circuits in this course.

Boolean algebra is a notation for combinational logic

Think of it as a notation for propositional logic used in circuit design.

Boolean algebra consists of the following elements and operations:

Example: from spec to code to logic to circuits

Suppose that we want to compute the number of lectures or sections remaining at the start of a given day of the week.

From spec to code …

public class Sessions {

    public static int classesLeft(int day, boolean lecture) {
        switch (day) {
            case 0: // SUNDAY
            case 1: // MONDAY
                return lecture ? 3 : 1;
            case 2: // TUESDAY
            case 3: // WEDNESDAY
                return lecture ? 2 : 1;
            case 4: // THURSDAY
                return lecture ? 1 : 1;
            case 5: // FRIDAY
                return lecture ? 1 : 0;
            default: //case 6: // SATURDAY
                return lecture ? 0 : 0;
        }
    }

     public static void main(String []args){
        System.out.println("(W, L) -> " + classesLeft(3,true));
        System.out.println("(M, S) -> " + classesLeft(1,false));
     }
}

Suppose that we need this function run really fast … To do that, we’ll implement a custom circuit (hardware accelerator!).

From code to combinational logic …

Recall the signature of our function:

• Inputs: day of the week (integers from 0 to 6), lecture flag (boolean).
• Output: number of sessions left (integer from 0 to 3).

How many bits for each input/output?

From code to combinational logic via a truth table

switch (day) {
  case 0: // SUNDAY
  case 1: // MONDAY
      return lecture ? 3 : 1;
  case 2: // TUESDAY
  case 3: // WEDNESDAY
      return lecture ? 2 : 1;
  case 4: // THURSDAY
      return lecture ? 1 : 1;
  case 5: // FRIDAY
      return lecture ? 1 : 0;
  default: // SATURDAY etc.
      return lecture ? 0 : 0;
}

From code to combinational logic via a truth table: $c_1$

From code to combinational logic via a truth table: $c_0$

From combinational logic to circuits

Here is $c_1$ as a circuit …

What can we do with the logic encoding?

So far, we’ve used the basics of Boolean algebra …

Boolean algebra consists of the following elements and operations:

Boolean operations satisfy the following axioms for any $a,b,c\in B$:

We can use the basics to prove some useful theorems

Example: proving theorems using the axioms

Example: proving theorems using truth tables

Example: simplifying (circuits) using Boolean algebra

Example: simplifying (circuits) using Boolean algebra

Here is the simplified $c_1$ circuit …