4.5 Testing for Validity in SL

4.5.2 The Truth Table Test for Validity

To test an SL argument for validity, we identify its logical form, then create a truth table with columns for each of the variables and sentence-forms in the argument’s form. Filling in columns of Ts and Fs under each of the operators in those sentence-forms will allow us to check for what we’re looking for: an instance of the argument’s form for which all premises turn out true and the conclusion turns out false. Finding such an instance demonstrates the argument’s invalidity, while failing to find one demonstrates its validity.

Example 1: An Argument Form with Two Variables

To see how this works, it will be useful to work through an example. Consider the following argument in English:

We’ll start by translating it into SL. Let ‘W’ stand for ‘The weather is bad’ and ‘D’ stand for ‘Shuttle takeoff gets delayed’. This is the argument in SL:

Next, we establish the logical form, replacing ‘W’ with ‘p’ and ‘D’ with ‘q’:

Then we need to plan the number of rows the table needs. And here is how to do that:

1. Note the number of different variables that occur in the argument-form —call that number ’n’
2. A table will need 2ⁿ rows.

For our argument, we have two variables—‘p’ and ‘q’—and so we need 2² = 4 rows. (If there were three variables, we would need 2³ = 8 rows; if there were four, 2⁴ = 16; and so on.)

Now we can set up a truth table, with base columns for each of the variables, columns for each of the sentence-forms, and the number of rows that will be needed. Here is the table we must fill in for this example:

First, we fill in the “base columns”. These are the columns for the variables. We do this systematically. Start with the right-most variable’s column (under ‘q’ in this case), and fill in Ts and Fs alternately: T, F, T, F, T, F, … as many times as you need—until you’ve got a truth-value in every row. That gives us this:

Next, we move to the base column to the left of the one we just filled in (under ‘p’ now), and fill in Ts and Fs by alternating in twos: T, T, F, F, T, T, F, F,… as many times as we need. The result is this:

If there were a third base column, we would fill in the Ts and Fs by alternating in fours: T, T, T, T, F, F, F, F…. For a fourth base column, we would alternate every other eight. And so on.

Next, we need to fill in columns of Ts and Fs under each of the operators in the statement-forms’ columns. To do this, we apply our knowledge of how to compute the truth-values of compounds in terms of the values of their components, consulting the operators’ truth table definitions. We know how to compute the values of p ⊃ q: it’s false when p is true and q false; true otherwise. We know how to compute the values of ~ p and ~ q: those are just the opposites of the values of p and q in each of the rows. Making these computations, we fill the table in thus:

Once the table is filled in, we check to see if we have a valid or invalid form. The mark of an invalid form is that it’s possible for the premises to be true and the conclusion false. The rows of the table represent the possibilities. The four possible outcomes of plugging in particular SL sentences for the two-variable table are:

1. Both true
2. The first is true, but the second false
3. The first false, but the second true
4. Both false

The reason we systematically fill in the base columns as described above is that the method ensures that our rows will collectively exhaust all these possible combinations.

So, to see if it’s possible for the premises to come out true and the conclusion to come out false, we check each of the rows, looking for one in which this happens—one in which there’s a T under ‘p ⊃ q’, a T under ‘~ p’, and an F under ‘~ q’. And we have one: in row 3, both premises come out true and the conclusion comes out false. This is enough to show that the argument about bad weather and shuttle takeoffs is invalid, as is any argument of that form.

The argument form we just tested is the very same form as the one we looked at (Example 2 Denying the Antecedent) in Section 2.2.1 where we took a brief look at a few formal fallacies. In our work right here, we have demonstrated that invalidity of the argument form for that example!

When we’re checking for validity, we’re looking for one thing, and one thing only: a row (or rows) in which the premises come out true and the conclusion comes out false. If we find one, we have shown that the argument is invalid. If we don’t find one, that indicates that it’s impossible for the premises to be true and the conclusion false—and so the argument is valid. Either way, the only thing we look for is a row with true premises and a false conclusion. Every other kind of row is irrelevant. It’s common for beginners to mistakenly think they are relevant. The fourth row in the table above, for example, looks significant. Everything comes out true in that row. Doesn’t that mean something—something good, like that the argument’s valid? No. Remember, each row represents a possibility; what row 4 shows is that it’s possible for the premises to be true and the conclusion true. But that’s not enough for validity. For an argument to be valid, the premises must guarantee the conclusion; whenever they’re true, the conclusion must be true. That it’s merely possible that they all come out true is not enough.

Supplement Your Understanding

Walk through a step-by-step summary of Example 1 with this slide presentation:  Example 1: Truth Table Test for Validity.  Link to it here or find it in the course table of contents at the end of Module 4. If you found the text description of this example complicated or confusing, scrolling through the slides at your own pace and reading each slide carefully may help clarify the truth table test for validity.

Example 2: An Argument Form with Three Variables

Let’s look at a more involved example, to see how the computation of the truth-values of the statement-forms must sometimes proceed in stages. The skill required here is nothing new—it’s just identifying main operators and computing the values of the simplest components first—but it takes careful attention to keep everything straight. Consider this SL argument – never mind what its English counterpart is:

To get its form, we replace ‘A’ with ‘p’, ‘B’ with ‘q’, and ‘X’ with ‘r’:

So our truth-table will look like this (eight rows because we have three variables: 2³ = 8):

Filling in the base columns as prescribed above—alternating every other one for the column under ‘r’, every two under ‘q’, and every four under ‘p’—we get:

Now we turn our attention to the three sentence-forms. We’ll start with the first premise, the compound sentence ‘(~ p • q) ∨ ~ r’. We need to compute the truth-value of this formula. We know how to do this, provided we have the truth-values of the simplest parts; we’ve solved problems like that already. The only difference in the case of truth tables is that there are multiple different assignments of truth-values to the simplest parts. In this case, there are eight different ways of assigning truth-values to ‘p’, ‘q’, and ‘r’; those are represented by the eight different rows of the table. So we’re solving a problem we know how to solve; we’re just doing it eight times.

We start by identifying the main operator of the compound formula. In this case, it’s the wedge. We have a disjunction; the left-hand disjunct is ‘(~ p • q)’, and the right-hand disjunct is ‘~ r’. To figure out what happens under the wedge in our table, we must first figure out the values of these components. Both disjuncts are themselves compound: ‘(~ p • q)’ is a conjunction, and ‘~ r’ is a negation. Let’s tackle the conjunction first. To figure out what happens under the dot, we need to know the values of ‘~ p’ and ‘q’. We know the values of ‘q’; that’s one of the base columns. We must compute the value of ‘~ p’. That’s easy: in each row, the value of ‘~ p’ will just be the opposite of the value of ‘p’. We note the values under the tilde, the operator that generates them:

To compute the value of the conjunction, we consider the result, in each row, of the truth-function for dot, where the inputs are the value under the tilde in ‘~ p’ and the value under ‘q’ in the base column. In rows 1 and 2, it’s F • T; in rows 3 and 4, F • F; and so on. The results:

The column we just produced, under the dot, gives us the range of truth-values for the left-hand disjunct in the first premise. We need the values of the right-hand disjunct. That’s just ‘~ r’, which is easy to compute: it’s just the opposite value of ‘r’ in every row:

Now we can finally determine the truth-values for the whole disjunction. We compute the value of the wedge’s truth-function, where the inputs are the columns under the dot, on the one hand, and the tilde from ‘~ r’ on the other. F ∨ F, F ∨ T, F ∨ F, and so on:

Since that column represents the range of possible values for the entire sentence-form, we highlight it. When we test for validity, we’re looking for rows where the premises as a whole come out true; we’ll be looking for the value under their main operators. To make that easier, just so we don’t lose track of things visually because of all those columns, we highlight the one under the main operator for that premise.

Next, the second premise, which is thankfully much less complex. It is, however, slightly tricky. We need to compute the value of a conditional here. But notice that things are a bit different than usual: the antecedent, ‘q’, has its base column to the right of the column for the consequent, ‘p’. That’s a bit awkward. We’re used to computing conditionals from left-to-right; we’ll have to mentally adjust to the fact that ‘q ⊃ p’ goes from right-to-left.  So in the first two rows, we compute T ⊃ T; but in rows 3 and 4, it’s F ⊃ T; in rows 5 and 6, it’s T ⊃ F (the only circumstance in which conditionals turn out false); an in rows 7 and 8, it’s F ⊃ F. Here is the result:

No need to highlight that column, as it’s the only one we produced for that premise, so there can be no confusion.

We finish the table by computing the values for the conclusion, which is easy, just the negation of the ‘r’ column:

Is the argument valid? We look for a row with true premises and a false conclusion. There are none. There are three rows in which both premises come out true, the second, fourth, and eighth rows, and in all three,  we also have a true conclusion. It is impossible for the premises to be true and the conclusion false, so the argument is valid.

Supplement Your Learning

Walk through a step-by-step summary of Example 2 with this slide presentation:  Example 2: Truth Table Test for Validity. Link to it here or find it in the course table of contents at the end of Module 4. If you found the description of this example complicated, scrolling through the slides at your own pace and reading each slide carefully may help clarify the truth table test for validity.

So that is how we test arguments for validity in SL. It’s a straightforward procedure; the main source of error is simple carelessness. Go step by step, keep careful track of what you’re doing, and it can be easy. It’s worth noting that the truth table test is what logicians call a “decision procedure”: it’s a rule-governed process (an algorithm) that is guaranteed to answer your question (in this case: valid or invalid?) in a finite number of steps. It is possible to program a computer to run the truth table test on arbitrarily long SL arguments. This is comforting since once one gets more than four variables or so, the process becomes unwieldy.