To do the short-cut method,

• 1. Set up the argument in the usual way (like you're going to do a full set of tables).
• 2. Go to the conclusion and make it false (by assigning the truth values 't' and 'f').
• 3. Go into the premises and try to make each one true.
• 4. If you accomplish #3, you know the argument is invalid.
• 5. If #3 cannot be accomplished, you know the argument is valid.

Example:

(A -> R)	-A	//	-R
				ft

Note there is only one way to make the conclusion false here; assign 't' to 'R'. Since 'R' has been given 't' in the conclusion, we'll go into the set of premises and give it 't' wherever it occurs, like so:

(A -> R)	-A	//	-R
      t				ft

The next step is to go into the premises and try to make each true. I'll start with the easy one, i.e., '-A'. There is only one way to make the second premise true; assign 'f' to 'A', making '-A' true, like so:

(A -> R)	-A	//	-R
      t		tf		ft

Now, since we gave 'A' 'f' in the second premise, we have to give it 'f' in the first premise as well, like so:

(A -> R)	-A	//	-R
 f    t		tf		ft

And, when we do that, we see that the first premise will be true, because when the antecedent is false and the consequent true in a conditional, the conditional itself is true. Here is how this would look.

(A -> R)	-A	//	-R
 f t  t		tf		ft

We have one row here instead of 4. Hence, "the short-cut" method.

Another example:

Here is the argument:

(E -> L)	(L -> D)   //	(E -> D)

The conclusion here is a Conditional. The only situation in which a Conditional is false is when the Antecedent is true and the Consequent is false. So, let's assign 't' to 'E' and 'f' to 'D', which puts an 'f' directly under the arrow in the conclusion, as so:

(E -> L)	(L -> D)	//	(E -> D)
			  		 t f  f  

Okay, now that we have given 't' to 'E' and 'f' to 'D', we need to go to the premises and assign those values consistently, which means giving 't' to 'E' in premise #1 and giving 'f' to 'D' in premise #2.

(E -> L)	(L -> D)	//	(E -> D)
 t                    f			 t f  f  

We now try to make both premises true. We start with either premise; let's start with premise #1 and make it true by assigning 't' to 'L'. That is the only thing we can do to make premise #1 true, and remember that the goal in the Short Cut Method is to try to make all the premises true and the conclusion false. So, let's assign 't' to 'L' in both premises because we have to be consistent in our assignments.

(E -> L)	(L -> D)	//	(E -> D)
 t    t          t    f			 t f  f  

It is now time to put the truth values under the arrows in both premises. In the first premise, we have a true Antecedent and a true Consequent. The truth value for the arrow in the first premise, then, has to be 't', in accord with the table for the Conditional. The truth value for the arrow in the second premise, however, will be 'f'. Here is what the Short Cut Table looks like for this argument:

(E -> L)	(L -> D)	//	(E -> D)
 t t  t          t f  f			 t f  f  

We see that the first premise of this argument is true (a 't' under the arrow) and that the second premise is false (an 'f' under the arrow). What has happened is that it was impossible for us to make both premises true here when we made the conclusion false. So, we were unable to achieve our goal of making all premises true and the conclusion false, which means that the original argument is valid. This would have been an eight-row table had we done it the long way.

End of lecture.