Truth tables offer a convenient technique to test for validity

but with the number of lines doubling for each variable we see that we need a more efficient way of working with them.  The trick is to see if we can force a bad line without having a contradiction.

Let's go back to the examples we had before.

Logic is easy if it is fun, and it is fun, so it must be easy.     F->E, F |- E
Logic is easy only if it is fun, and it is fun, so it must be easy.   E->F, F |- E

F -> E   F   E         E -> F   F   E
   x        1    0             1       1    0

On the left we see that we could not have both premises true and the conclusion false, since plugging in the values for F and E makes the expression  F->E false.    On the right we can do just this.

For practice let's see what happens with bad lines with the arguments
P->(QvR), ~Q |- ~P  and  P->(Q&R), ~Q |- ~P
when we work out complete eight-line truth tables.
 
 
    P       Q      R P->(QvR)    ~Q    ~P 
    1       1     1      1    0  0
    1      1     0     1    0  0
    1      0     1     1    1  0
    1      0     0     0    1  0
    0       1     1     1    0  1
    0      1     0     1    0  1
    0      0     1     1    1  1
    0      0     0     1    1  1
The third line is a "bad line"--true premises and a false conclusion.
The argument form is invalid.
 
    P      Q     R P->(Q&R)   ~Q  ~P
    1     1    1    1   0  0
    1     1    0    0   0  0
    1     0    1    0   1  0
    1     0    0    0   1  0
    0     1    1    1   0  1
    0     1    0    0   0  1
    0     0    1    0   1  1
    0     0    0    0   1  1
There are no bad lines--no instances of lines with true premises and a false conclusion.
The argument form is valid.

Please note that if you are using the Explorer browser on a PC you can do these on the computer for yourself with the PLN programs available from the files in the community logic@yahoogroups.com.   To use the program to test for validity, type the premises (using capital letters) in postfix literal notation.
P->(QvR), ~Q |- ~P   becomes  PQROC, QN |- PN
P->(Q&R), ~Q |- ~P  becomes  PQRAC, QN |- PN

Now let's use our "reverse method" on both patterns.

P  Q  R    P -> (Q v R)   ~Q   ~P       P  Q  R    P -> (Q & R)   ~Q   ~P
1  0   1         1                 1      0         1   0  x         1                   1      0

In the first, having R true allows the implication to be true since QvR is now true.  In the second we cannot force the line since having Q false with P true automatically makes the implication false (Q&R cannot be true).

To use the reverse method, automatically set the premises as true and the conclusion as false, then attempt to find at least one instance in which you can successfully account for all variables.
 

Practice exercises


Test the validity of the following argument forms.

P -> Q,  Q -> R  |-  P-> R
P -> Q,  R -> Q  |-  P -> R
P -> Q,  R -> S,  P v R   |-  Q v S
P -> ~(Q & R), P & Q  |- ~R
P v (Q & R) ,  ~P  |- Q & R
P v (Q & R),  Q & R  |- ~P

(you should find bad lines possible in just two of these)