Arguments

The three classic elements of the argument are the modus ponens (also called detachment):
(p & (p -> q)) -> q

pq p -> qp & (p -> q)(p & (p -> q)) -> q
TTTTT
TFFFT
FTTFT
FFTFT

 the modus tollens:
(~q & (p -> q)) -> ~p

pq~p~q p -> q~q & (p -> q)(~q & (p -> q)) -> ~p
TTFFTFT
TFFTFFT
FTTFTFT
FFTTTTT

 and the syllogism:
((p -> q) & (q -> r)) -> (p -> r)

pqrp -> q q -> rp -> r(p -> q) & (q -> r) ((p -> q) & (q -> r)) -> (p -> r)
TTTTTTTT
TTFTFFFT
TFTFTTFT
TFFFTFFT
FTTTTTTT
FTFTFTFT
FFTTTTTT
FFFTTTTT

Note that the syllogism is essentially the property of transitivity of the logical operator IMPLIES. These argumentative constructions (!) are the bases for the arguments we will discuss below.

Consider the following scenario:

You just upgraded to a new motherboard in your computer, but because the new motherboard did not support your old CPU and memory, you had to replace those as well. Now the system is crashing randomly and you don't know what to do. The store where you purchased the new hardware tested your memory and pronounced it OK. You attempt to reason as follows:

  1. If the BIOS test runs fine, the CPU and motherboard must be OK.
  2. If the CPU and motherboard and memory are all OK, then there must be a flaw in the way your OS handles the new motherboard.
  3. The BIOS test runs fine and the memory is OK.
  4. Therefore there must be a flaw in the OS.
You assign logical variables to the propositions as follows: so that your argument is represented as:
  1. p -> q
  2. (q & s) -> r
  3. p & s
  4. therefore r
This representation points out a fact of life: any reasonably interesting argument involves more than three logical variables; this is the exception to our general statement earlier that we would usually confine ourselves to logical expressions involving at most three variables. In the forgoing, we will refer to the propositions as premises, as is usually done with the propositions representing assumptions in an argument.

In order to test the validity of an argument, you must construct a truth table for the following logical expression:

(premise 1 & premise 2 & .... & premise n) -> conclusion
so in this case, we must construct a truth table for:
((p ->q) & ((q & s) -> r) & (p & s)) -> r
If the column for that expression indicates that it is a tautology, then the argument is valid:

(p ->q) & ((q & s) ->((p ->q) & ((q & s) -> r) &
pqrs p -> qq & s(q & s) -> r p & sr) & (p & s)(p & s)) -> r
TTTT TTTTTT
TTTF TFTFFT
TTFT TTFTFT
TTFF TFTFFT
TFTT FFTTFT
TFTF FFTFFT
TFFT FFTTFT
TFFF FFTFFT
FTTT TTTFFT
FTTF TFTFFT
FTFT TTFFFT
FTFF TFTFFT
FFTT TFTFFT
FFTF TFTFFT
FFFT TFTFFT
FFFF TFTFFT

Since the final column is all Ts, the argument is valid.

It is amusing to note that this problem was encountered by the author during the writing of this text. It turns out that while this argument was valid, and a bug report was submitted to the authors of the OS, the actual problem was bad memory after all! The vendor's memory tester was woefully inadequate for finding the kind of errors that were causing the problem; a more intensive test produced in excess of 4,000 errors in a 17 hour test of the 512 MB of memory.

So while the argument was valid, there is no guarantee that the conclusion is true if any of the premises are false. As we have previously stated, anything can follow from a false premise. It is often more colloquially expressed as "garbage in, garbage out".

Let us try another argument in the same vein. Your system is running slowly, and wishing to analyze the problem logically you make the following argument:

  1. if the slowness is system-wide, then it is either a hardware problem or an OS problem
  2. if new hardware was just installed, it is either a hardware problem or a configuration problem
  3. the slowness is system-wide and new hardware was just installed
  4. therefore it is a hardware problem
You assign the logical variables as follows: so that your argument is represented as:
  1. p -> (q | r)
  2. s -> (q | t)
  3. p & s
  4. therefore q
Constructing a truth table to test the validity of the argument, we see:

(p ->(q | r)) & (s ->((p ->(q | r)) & (s ->(q | t))
pqrst q | rq | tp -> (q | r) s -> (q | t)p & s(q | t)) & (p & s) & (p & s)) -> q
TTTTT TTTTTTT
TTTTF TTTTTTT
TTTFT TTTTFFT
TTTFF TTTTFFT
TTFTT TTTTTTT
TTFTF TTTTTTT
TTFFT TTTTFFT
TTFFF TTTTFFT
TFTTT TTTTTTF
TFTTF TFTFTFT
TFTFT TTTTFFT
TFTFF TFTTFFT
TFFTT FTFTTFT
TFFTF FFFFTFT
TFFFT FTFTFFT
TFFFF FFFTFFT
FTTTT TTTTFFT
FTTTF TTTTFFT
FTTFT TTTTFFT
FTTFF TTTTFFT
FTFTT TTTTFFT
FTFTF TTTTFFT
FTFFT TTTTFFT
FTFFF TTTTFFT
FFTTT TTTTFFT
FFTTF TFTFFFT
FFTFT TTTTFFT
FFTFF TFTTFFT
FFFTT FTTTFFT
FFFTF FFTFFFT
FFFFT FTTTFFT
FFFFF FFTTFFT

The presence of even a single F in the final column indicates that this argument was not valid, even though it may have been a reasonable approach in troubleshooting. The flaw in the reasoning was that we didn't account for the possibility that it could be BOTH an OS bug and a configuration error: the line containing the F in the final column began with all of the variables being T except q. This corresponds to the situation:

In the next section we move on to a generalization of logic called Boolean Algebra.

Go to:Title PageTable of ContentsIndex

©2002, Kenneth R. Koehler. All Rights Reserved. This document may be freely reproduced provided that this copyright notice is included.

Please send comments or suggestions to the author.