Here is a link to my sample Truth Table Generator.

An important part of mathematics and computer programming is understanding conditional expressions. These are statements that generally read like “if [condition is true], then [execute a sequence of statements]”. A simple example of this is that if we wanted to print out every even number, our conditional would be if (2 divides into x with remainder 0) then print x, or in JavaScript

if (x % 2 == 0)

{

document.write(“x”);

}

Conditional expressions belong to the world of Boolean logic. These are expressions that evaluate to true or false, depending on the values of the variables involved in this expression. When we are dealing with real world examples, this is generally a statement like “X is an even number” (for some number X) or “The element x is in the set Y” (for some element x and some set Y). Notice that both the statements can be evaluated as true or false statements. We are interested in understanding the Boolean logic behind combining a number of these expressions, and understanding how the evaluation of the simpler expressions help determine the values of the more complex formulas.

One way of doing this in mathematics is by constructing a truth table. A truth table is a table that shows how a Boolean expression’s value can be computed. The procedure in constructing a truth table is to first add a column to the table for each variable involved in the expression. Then we compute the value of each sub-expression of the expression in its own column until we have computed the entire expression in the final column.

There are four logical operators that we will be working with

– The negation operator (¬P), which returns true if the variable P is false, and returns false otherwise.

– the or operator (P ? Q), which returns true if P is true or Q is true, or if both are true, and returns false otherwise.

– the and operator (P ? Q), which returns true if both P and Q are true, and returns false otherwise.

– the implies operator (P ? Q), which returns false if P is true and Q is false, and returns true otherwise.

An example of this is below:

Suppose we have the following formula:

((Q ? P) ? (¬ (Q ? R)))

The truth table would then be:

P |
Q |
R |
(Q ? R) |
(¬ (Q ? R)) |
(Q ? P) |
((Q ? P) ? (¬ (Q ? R))) |

F |
F |
F |
F |
T |
F |
T |

F |
F |
T |
F |
T |
F |
T |

F |
T |
F |
F |
T |
F |
T |

F |
T |
T |
T |
F |
F |
T |

T |
F |
F |
F |
T |
F |
F |

T |
F |
T |
F |
T |
F |
F |

T |
T |
F |
F |
T |
T |
T |

T |
T |
T |
T |
F |
T |
T |

First, notice that the truth table has 8 rows. This corresponds to the 8 distinct possible combinations of values for the three variables. The number 8 is also = 2^{3}, which is not a mistake. In general, if an expression has n variables, its corresponding truth table will contain 2^{n} rows. In this truth table, column 4 represents the sub-expression (Q ? R). Notice that the only times this expression evaluates to true is when both Q nd R are true. The next column is (¬ (Q ? R)), the negation of (Q ? R), so the values in this column are the opposite of those in the previous column. We follow that up with the column for the sub-expression (Q ? P), which has a value of true only when the variables Q and P both have values of true. And the final column is the expression we started with ((Q ? P) ? (¬ (Q ? R))), but we can now evaluate the expression based on the two previous columns. Notice that the values of true in this column only correspond to when at least one of the previous two columns evaluated to true.

Check out my script on truth tables to see more examples and learn more about truth tables.