Introduction

We ended the previous part of the series looking at the truth tables of the 5 Boolean operators. We’re going to shift our focus from simply looking at individual statements and how they can be pieced together with operators, to looking at whole arguments. Recap: an argument is a set of statements with a number of premises and a conclusion supposed to follow from the premises. Just as you can construct truth tables for the operators, you can construct truth tables for entire arguments. This provides us with a way of evaluating its soundness and validity.

Testing validity using truth tables will turn out to be a largely mechanical procedure. If you’ve ever wanted to roleplay a computer carrying out an algorithm, today is your lucky day! The truth table method does, however, require you to be very familiar with the truth tables of the operators. Moreover, you’ll need to be comfortable with brackets/figuring out which is the main operator in a compound sentence. The latter is something we haven’t really spent any time on, so I am assuming that you are reasonably familiar with this. If not, here’s a quick guide (or you can just search “find major operator logic” on your search engine of choice). I will include the tables from last tutorial here so that you can easily refer back to them; but, in the long run, it’s best to commit these to memory.

Cast of Characters

Review: Truth Tables for the Operators

Constructing a Truth table:

The truth table method is a mechanistic way of testing the validity of an argument. Once you've drawn up the table, you can quickly see if there is a counterexample (i.e. a row in the table where all the premises are true and conclusion false). The annoying thing about the truth table method, however, is that it very quickly becomes unfeasible (due to the exponential increase in possible cases with each additional variable). As such, I will only stick to a maximum of 3 unique variables in these examples. It should be noted that I will call capital letters argument instances variables even though, as we’ve learned, these are actually instances. This is purely for the sake of brevity. Let’s go through the procedure with the following example:

Becky has just written lyrics for a song she has yet to compose. She’s thinking it’s going to be a healthy mixture of Scatman John and Napalm Death. Before she composes the song, she wants you to check the validity of the lyrics. Here are the lyrics:

Step 1: Count the number of variables in the argument

Looking at Becky’s lyrics, it seems as if there are 2 variables (technically instances): A, B. These will become the basis of our base columns. We will put these in the far left of our table, like this:

Step 2: horizontally list the premises and conclusion right of the variables

To clearly distinguish between premises we will separate these by commas, and we’ll use the Triforce-like symbol before the conclusion.

Step 3: Construct the Base columns

Step 4: compute the truth values of premises and conclusion for all combinations

In other words, compute the truth values (using the tables for the Boolean operators you’ve now memorized/tattooed onto your arms) for all rows in the truth table.

Step 5: check for counterexamples

Look at your filled out table and see if there is any row in which all premises are true and the conclusion false. If there is, the argument is invalid; if not, then it’s valid. In Becky’s case there are no counterexamples, so her lyrics are valid. Great job, Becky - can’t wait to hear the song on your Soundcloud!

Method Summary

Here’s the basic method of filling out truth tables and checking argument validity in point form:

Truth Tables for arguments with Subformulas

Looks like Tony really bungled up this one. Let’s help him out. 

This one is a bit trickier because of the nested compound expressions. These nested propositions are often called subformulas because, while they have their own Boolean operations going on, they are ultimately subsumed under a larger parent sentence. We will need a few more rows (but not more columns - still just 2 variables!) in our truth table because we have to deal with the outcome of the subformulas’ operators before we can evaluate the major operator for each premise/conclusion. So we’re going to have to add some extra steps to our truth table method.

Steps 1-3 will be the exact same as for Becky’s lyrics, so let’s start from Step 3.

Notice how we’ve left more space for each operation. Essentially, what we need to do is sort out the truth values for the subformulas first. Once we have those, we can compute the truth values for the major operators for each premise/conclusion. The values under the major operators will be the ones we use to determine the validity of the argument. Let’s observe which operators we need to deal with first (blue), second (purple), and last (red). As you can tell (hopefully), the last operators (the red ones) are the main operators for each sentence.

We’ll call these colour codes (and associated numbers) levels. Now let’s go through levels 1-3 for both premises and the conclusion.

To reiterate: what we’re doing here is that we’re comparing the operators in the premises to the truth values in the base columns. We’re evaluating these on the rules for the 5 operators. Now let’s do level 2.

Notice here that we’re getting a little more abstract. For the conjunction in the second premise, we’re using the base column for A, but we’re now using our computed values for the negation of B. Similarly, for the negation in the very beginning of premise 1, we’re actually not using the base column directly at all: we’re taking our computed values for the conjunction (1) and negating that (essentially reversing the truth values for (1) ). This has to do with the hierarchy of the levels. The truth values computed at Level 1 are used to compute those at Level 2, which finally are used to compute Level 3.

Now we turn to Level 3: we will be using the values computed at Level 2 (on either side of the operator) to determine the resulting truth value for each major operator. In order to not get lost in all the rows, let’s remove the values for Level 1. We don’t need them anymore — all we need are the Level 2 values. Let’s also make it clear which is the main operator by making it red. The purple bows show which truth-value columns we are comparing in determining the truth values for the Level 3 columns.

Now we’ve constructed our truth table. To make it even clearer, here’s what it looks like with JUST the major operator columns. This will make it easier for us to see if there are any counterexamples.

Okay, so let’s look for counterexamples. There’s only one row where the conclusion is false, so this would be the only danger zone. But, in this row, one of the premises is false. So, the argument is valid (recall the stuff about validity, form and instance in Part One)

Tony is impressed with your lawn mower mechanics skills. He successfully restarts it and mows the lawn with the confidence of a middle-aged cyclist in traffic. You did good work today.

Part three Wrap-Up

What we have learned so far

In this section of the tutorial, we learned how to construct truth tables in order to check argument validity. We evaluated Becky’s lyrics for her upcoming scat-singing/grindcore banger. We also helped Tony and in the process learned a few extra steps in computing subformulas in more complicated arguments. The basic recipe for a truth table is: 

1. Count the number of variables and put these in the top left

2. Horizontally list the premises and conclusion right of the variables

3. Construct the base columns

4. Compute truth values for premises and conclusion (all rows)

5. Check for counterexamples

Where we are going next

The next part is where things get really fun and interesting. We’re going to learn to check for the validity of arguments using the proof method. This will enable us to check validity for arguments with many variables, without having to construct a massive truth table. The proof method largely relies on a set of inference rules and replacement rules. We will start by learning the 8 basic inference rules. And, as you might suspect, memorizing these rules will make your life SO MUCH easier. The proof method is where logic starts becoming interesting and useful, so you’re in for a treat.