Data Tables!
Truth tables are used to easily describe boolean algebra operations. Boolean algebra is an branch of mathematics dealing with, rather than the vast stretches of integers, two digits: 1 and 0 (or true and false).
There are many different types of boolean operations, and we’ll be covering them all here. We also have an interactive quiz that allows you to see how good you are at this!
NOT (and states).
Boolean states
As you may know, binary and boolean states are very simple, 1 and 0, true and false. Boolean operations occur based off the comparison of two binary values, or inversion. Thus, these two boolean states are imperative to understanding. 1 and 0 are inverses, like on to off. They are also mutually exclusive. You can’t have a state that’s both on and off at the same time!
NOT
The NOT operator inverses whatever it is affecting.
The most basic operation is one that does
Question: What NOT(true)
False
Operation(s): AND
AND
AND is a boolean operation that you see in your everyday life! And in english is a conjugation, which denotes a combination of two or more objects, and in programming and binary math, it is very similar.
For Example, in English you’d say:
Take this and that
and you would not be fulfilling the request unless both this and that were taken.
Similarly, in Binary math, when you use the and operator, you are only considering the output true unless both are true.
AND: (XY)
python: True and False
javascript: true && false
java: true && false
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | FALSE |
| FALSE | TRUE | FALSE |
| FALSE | FALSE | FALSE |
NAND
NAND is the not operator for and. In other words, it is the complete inverse of the AND function.
In english this would be: DON'T take this and that. Note how the DON'T is a negative, asking you not to take both, but to take either.
In binary this would be:
NAND: (XY)’ (The ' denotes inverse)
python: not (True and False)
javascript: !(true && false)
java: !(true && false)
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | FALSE |
| TRUE | FALSE | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | TRUE |
Inhibition
Inhibition is a pseudo-and (not actual jargon) function. Written in plain-text, the Inhibition function can be two things: X·NOT(Y) or NOT(X)·Y. It is when one input is True, but the other is False. This is the inverse of either X or Y, but not both. It can be written as X or Y Inhibition.
Inbiting X: (X’Y)
python: (Not X)&Y
javascript: !(X)&&Y
java: !(X)&&Y
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | FALSE |
| TRUE | FALSE | FALSE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | FALSE |
Inbiting Y: (XY’)
python: X&(Not Y)
javascript: X&&!(Y)
java: X&&!(Y)
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | FALSE |
| TRUE | FALSE | TRUE |
| FALSE | TRUE | FALSE |
| FALSE | FALSE | FALSE |
Note how the first and second terms (in their respective inhibitions) are inverted.
Question: What would 1(0) be? What about (1)(0)’? What about true&&false?
Operation(s): OR
AND operations require both arguments in the function to be true in order to return true. However, or operations only require one to be true to return true. OR gates being more forgiving makes them great to check for different cases that AND simply cannot take. However, there are many variations that allow for greater specificity.
OR
English Example: Take either this or that. Here, if you take this, you fulfill the request. But if you also took that, you would also fulfill the request. In fact, if you took both, you’d actually be fulfilling the request, because they didn’t specify to not take both.
Translated to binary, this is:
OR: (X + Y)
python: True or False
javascript: true || false
java: true || false
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | FALSE |
NOR
Remember NAND? This is NAND, but for or. It takes the complete output of OR, and takes the inverse of it.
NOR: (X + Y)’
python: not (True or False)
javascript: !(true || false)
java: !(true || false)
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | False |
| TRUE | FALSE | FALSE |
| FALSE | TRUE | FALSE |
| FALSE | FALSE | True |
| **Question: What would 1+0 be? What about !(true | false)** |
XOR
XOR, eXclusive OR, or bitwise OR allows for a coder to only return true if specifically only one input is true, but the other input is false. For example, this would be a situation where, if you have two objects, you can only take one or the other, not both, and not none.
XOR: (X^Y)
python: True^False
javascript: true^false
java: true^false
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | FALSE |
| TRUE | FALSE | TRUE |
| FALSE | TRUE | TRUE |
| FALSE | FALSE | FALSE |
XNOR
XNOR is the Exclusive NOR. This is the direct inverse of the XOR function, so it would be pretty simple.
XNOR: (X^Y)’
python: not (True^False)
javascript: !(true^false)
java: !(true^false)
| X | Y | Output |
|---|---|---|
| TRUE | TRUE | TRUE |
| TRUE | FALSE | FALSE |
| FALSE | TRUE | FALSE |
| FALSE | FALSE | TRUE |
Question: what would true^false be? what would !(false^false) be?
True. True.
PEMDASNAO
- Parenthesis
- Exponents
- Mutliplication/Divsion
- Addition/Subtraction
- NOT
- AND
- OR IN THIS ORDER
De Morgan’s Law
Above is an image of the important boolean algebra laws that are necessary to know. Not memorize, but know. The most important one we will cover is De Morgan’s law. Mainly because it is the most complex. As per wikipedia:
The rules can be expressed in English as:
- The negation of a disjunction is the conjunction of the negations
- The negation of a conjunction is the disjunction of the negations
Notice how it the conjunction references AND and disjunction represents OR. Thus, this can be restated as…
- NOT (A OR B) is equivalent to (NOT A) AND (NOT B)
- NOT (A AND B) is equivalent to (NOT A) OR (NOT B)
This is very useful when evaluating boolean expressions.
Hacks
Complete the weird questions below.
Weird questions
- !(true)&&(false) = ? what in boolean values?
false
- not ((((true and not (false)) ^ false) ^ true) && false) (remember PEMDASNAO!)\
not ((((true and not (false)) ^ false) ^ true) && false) not ((((true) ^ false) ^ true) && false) not (((true) ^ true) && false) not (false && false)
true
- Prove the following: !A * !(B + !C) = !A * (!B * !C)
You can’t prove it since if you distributed it all out you would get: not A and not B and C = not A and not B and not C
- 420 && 66 (Hint, convert to binary, then perform the operation)
110100100 = 420 1000010 = 66 ————– 000000000 = 0
- If you got this one, try 89 OR 42
01011001 = 89 00101010 = 42 ————– 01111011 = 123
For each example, you can use code, but then show your work and how you got it. Please ask questions if you are confused!