In an argument we give reasons in order that we may draw a conclusion about what stance we should take with regard to a claim that might be made. In constructing a typology of argument, then, it is worthwhile to begin by positing four basic features to be used in your classification, which I shall call the bases, the argument-making operation, the conclusible, and the stance. The argument-making operation, which I will represent by R, I will take as primitive; to apply R is to do whatever is done to turn materials for an argument into an actual argument, and it is not of interest here what that involves. An argument has bases, starting points; these are the materials, the things that can be given as reasons for a conclusion. It is also not of interest here what those things may be, whether propositions, or sensory observations, or anything else. It has a conclusible, which is a candidate for being a conclusion; and it has a stance with regard to that conclusible. It is the combination of the conclusible and the stance which is the conclusion. For instance, my conclusion may involve taking the conclusible, "The sky is green" to be false. One important point with regard to the stance is what values we allow for it. I will allow four, T, F, ~T, and ~F; that is, I will be taking T and F as contraries. A conclusible may be neither true nor false. Some would prefer not to do this, and instead to take T and F as contradictory. This does not make a major difference to anything that follows if F is taken as equivalent to ~T and T as equivalent to ~F, then everything remains the same except that the patterns become simpler.
Given this, we can represent an argument along the following lines:
a : Ra(XT)
where a is the base, X the conclusible, and T indicates that it is taken as true.
We then get the following types of argument:
a : Ra(XT)
a : Ra(XF)
a : Ra(X~T)
a : Ra(X~F)
It is clear that this is not a very sophisticated typology on its own, and is certainly not exhaustive, representing only cases where something, call it a, is given as a reason for regarding X as true, false, not true, and not false respectively. To do justice to the range of possible arguments, we should introduce a further set of sophistications. The first is ~R. I use the negation sign because ~Ra represents an argument in which a is put forward as a nonreason for the conclusion. It's important to recognize, however, that ~R is as much an argument-making operation as R; the difference is that R indicates arguments where a is made to be relevant to the conclusion, and ~R indicates those where this link is severed. ~R-style arguments are one way in which we argue against R-style arguments.
We further need to recognize that we argue not merely for the basic stances already noted but for modal versions of them as well. That is, we don't merely fuss about whether arguments are true or false, or not, but also about the necessity and possibility of these. I will use L for the strong modality (necessity) and M for the weak modality (possibility). It is important, however, to distinguish two very different applications of modality in this regard, which can be represented by the difference between the two following types of argument:
a : RaL(XT)
a : Ra(XLT)
The first of these represents a case where the conclusion is that X is a necessary truth. The second represents a case where the conclusion is that X is necessarily true. Despite the verbal similarity the two are not the same. For if we take X itself as a (i.e., as the base), this trivial argument can legitimately be made for any X:
(XT) : R(XT)(XLT)
It is, in fact, the case, that, when X is taken as given, X is necessarily true. This is hypothetical necessity. If we take it as given that Socrates is sitting, it follows necessarily that Socrates is sitting. It does not follow, however, that "Socrates is sitting" is a necessary truth, because it is possible for Socrates not to be sitting.
I will also stipulate that R can take an argument within its scope. That is, you can have arguments like this:
a, b : Ra(Rb(XT)T)
Which represents the case where it is concluded, on the basis of a, that b is a truly a reason for concluding (XT). There are some complications with this. But in what follows I will mostly be focusing on the one-base case, in order to keep it simple and easier to understand, and only touch on these more complicated types of argument here and there.
Given these sophistications, we can begin constructing hierarchies of arguments. There are four notable ones. (In what follows, I will, to avoid clutter, abbreviate. For instance, a : Ra(XT) will simply be labeled, "R(XT)".) This is what I will call R1:
| RL(XT) | |
| RL(X~F) | R(XLT) |
| R(XL~F) | R(XT) |
| R(X~F) | R(XMT) |
| R(XM~F) | RM(XT) |
| RM(X~F) | |
The following hierarchy I will call R2:
| RL(XF) | |
| R(XLF) | RL(X~T) |
| R(XF) | RXL~T) |
| R(XMF) | R(X~T) |
| RM(XF) | R(XM~T) |
| RM(X~T) | |
The following I will call ~R1:
| ~RM(X~F) | |
| ~RM(XT) | ~R(XM~F) |
| ~R(XMT) | ~R(X~F) |
| ~R(XT) | ~R(XL~F) |
| ~R(XLT) | ~RL(X~F) |
| ~RL(XT) | |
And this is ~R2:
| ~RM(X~T) | |
| ~R(XM~T) | ~R(XF) |
| ~R(X~T) | ~R(XM~F) |
| ~R(XL~T) | ~R(XF) |
| ~RL(X~T) | ~R(XLF) |
| ~RL(XF) | |
These forty types of one-base arguments are not exhaustive even of one-base arguments; as we will see later, there is at least one more sophistication that has to be introduced into the system. Nor are they unrelated. As we shall also see, there are interesting and, for the purposes of argument, important patterns of relations among them. We will begin discussing these patterns in the next post on this subject.
Continue to Part II.
