Boolean Algebra

Objectives

1. Understand the boolean operators and some basic boolean algebra

Notes

• Some material is covered IN the book.
  • But most is not.
  • Sorry, this is going to be a bit of theory.
  • You will learn this (I hope) in discrete structures.
    • But that is not a prerequisite- so we will cover it briefly here.
• To start:
  • This system is based on the work of George Bool, an English Mathematician, Philosopher and Logician.
  • Proposed much of this in 1840s.
  • He wanted to formalize a systematic investigation of human thought.
• Remember this is based on the values of true and false.
  • As opposed to algebra where we look at the real numbers
• Will investigate three operators
  • In algebra we focus on addition, subtraction, ...
  • in boolean algebra we focus on and, or and not.
  • There are more than these, but this will do for now.
• We explore boolean algebra differently than regular algebra.
  • In regular algebra, there are infinite numbers of inputs.
  • So y = 3x+2
    • Has infinite inputs for x
    • And infinite outputs for y.
  • So we tend to do things a bit differently at the beginning.
    • We build truth tables.
    • A single value truth table: y = f(p)

      INPUT (p)	OUTPUT (q)
      false	f(false)
      true	f(true)

    • To make it easier, we will use T for true and F for false.
    • Two value truth table y = f(p,q);

      p	q	f(p,q)
      f	f	f(f,f)
      f	t	f(f,t)
      t	f	f(t,f)
      t	t	f(t,t)

  • You also see 0 for false and 1 for true. (Architecture)
• A note on notation,
  • When you lean this is different areas you will use different notation
    • T/F in math/logic
    • 1/0 in architecture
    • And: conjunction, * or (·), ∧, &&
    • In this case, you need to be context aware and use the proper symbol/words.
• The not operator
  • This changes the truthfulness of the expression
    • If the expression is true, not expression is false
    • If the expression is false, not expression is true.
  • This is a unary operator it takes one value.
  • We usually represent it as a ! in programming,

  • p	!p
    f	t
    t	f

  • This is built into !=

  • int keepGoing = 0;
    
    while (keepGoing != 1) {
        System.out.print("Enter a 0 to keep going or a 1 to stop ");
        ...
    } 

  • We will see more of this in the future
  • Some example code:

    boolean p;
    p = false;
    System.out.println("   p   |  not p");
    System.out.println("---------------");
    System.out.printf("%7b|%7b\n",p, !p);
    p = true;
    System.out.printf("%7b|%7b\n",p, !p); 

• The and operator
  • This is a binary operator as it takes two arguments.
  • p and q is true if both p is true and q is true.
  • In code we use &&, but we can use the word and in logic,

    p	q	p &&q
    f	f	f
    f	t	f
    t	f	f
    t	t	t

  • System.out.printf("\n\n");
    p = false; 
    q = false;
    System.out.println("    p      q  | p && q");
    System.out.println("----------------------");
    System.out.printf("%7b%7b|%7b\n",p,q, p&&q);
    q = true;
    System.out.printf("%7b%7b|%7b\n",p,q, p&&q);
    p = true;
    q = false;
    System.out.printf("%7b%7b|%7b\n",p,q, p&&q);
    q = true;
    System.out.printf("%7b%7b|%7b\n",p,q, p&&q); 

  • We use this when we have two conditions

  • while ( keepGoing != 0 && moneyOnHand > 0) { 

  • We might also use this to bound a computation

  • while ( points > 0  && points  < 100) { 

• The or operator
  • This is also a binary operator.
  • It is true if one or the other or both inputs are true.
  • p or q is true if p is true, if q is true, or if both p and q are true.
  • This is called the inclusive or
  • There is another or called the exclusive or, but we will not deal with that now.
  • In java, || represents or

    p	q	p || q
    f	f	f
    f	t	t
    t	f	t
    t	t	t

  • p = false;
    q = false;
    System.out.println("    p      q  | p || q");
    System.out.println("----------------------");
    System.out.printf("%7b%7b|%7b\n",p,q, p||q);
    q = true;
    System.out.printf("%7b%7b|%7b\n",p,q, p||q);
    p = true;
    q = false;
    System.out.printf("%7b%7b|%7b\n",p,q, p||q);
    q = true;
    System.out.printf("%7b%7b|%7b\n",p,q, p||q); 

  • We will use this like the and
• Short Circuit Evaluation
  • Note that if the first input to or is true, the entire expression is true.

  • p	q	p || q
    t	f	t
    t	t	t

  • (true || ANYTHING) is true.
  • Because of this, the compiler can decide not to evaluate the second part of the expression.
  • This is called Short circuit evaluation.
  • It is not a problem if you are not doing any computations in the expression.
  • But we may do some later.
  • The same is true for and (false && ANYTHING) is false.
• DeMorgan's law
  • Be careful noting expressions involving and or or.
  • !( keepGoing == 1 and moneyOnHand > 0)
    • IS NOT keepGoing != 1 and moneyOnHand <= 0)
    • It IS keepGoing != 1 or moneyOnHand <= 0)
  • In general DeMorgan's says
    • Not the individual expressions
    • Change the connecting and to or, or the connecting or to and.

  • p = false;
    q = false;
    
    System.out.println("    p      q  | !(p || q)  !p || !q  |  !p && !q");
    System.out.println("------------------------------------------------");
    System.out.printf("%7b%7b|%7b %10b %12b\n",p,q, !(p||q), !p||!q, !p && !q);
    q = true;
    System.out.printf("%7b%7b|%7b %10b %12b\n",p,q, !(p||q), !p||!q, !p && !q);
    p = true; 
    q = false;
    System.out.printf("%7b%7b|%7b %10b %12b\n",p,q, !(p||q), !p||!q, !p && !q);
    q = true;
    System.out.printf("%7b%7b|%7b %10b %12b\n",p,q, !(p||q), !p||!q, !p && !q); 

  • Will produce:

        p      q  | !(p || q)  !p || !q  |  !p && !q
    ------------------------------------------------
      false  false|   true       true         true
      false   true|  false       true        false
       true  false|  false       true        false
       true   true|  false      false        false 

• logicDemo.java