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? 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) 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? true
not ((((true and not (false)) ^ false) ^ true) && false) (remember PEMDASNAO!) true
Prove the following: !A * !(B + !C) = !A * (!B * !C) Apply De Morgan’s Law to the left side, and we get: !A * (!B * C) = !A * (!B * !C) Apply Distribution Law to the left side, and we get: !A * !B * C = !A * (!B * !C) Apply Distribution Law to the right side, and we get: !A * !B * C = !A * !B * !C
420 && 66 (Hint, convert to binary, then perform the operation) 110100100 && 1000101 = 69
1. If you got this one, try 89 OR 42 1011001 OR 101010 = 89

For each example, you can use code, but then show your work and how you got it. Please ask questions if you are confused!

Binary Logic