Monday, August 06, 2007

Notes Toward a Formal Typology of Argument IV

In the first post I laid out in a rough way the notation for the typology.
In the second post I introduced the notion of attenuation and used it to establish hierarchies of arguments.
In the third post I introduced the notion of preclusion and used it to show how distinct hierarchies of arguments are interrelated.

That's the basic typology. In this post I will be looking at an optional bit of notation that doesn't fundamentally change the typology but gives it slightly more power for classifying arguments. However, before I do that I need to make a small but nonetheless important correction to my account in the above posts.

The problem with those posts is that the hierarchies presented in them are all incomplete. The relative orderings of arguments are right, as are the preclusion relations; but not all argument-types that should have been included were included, through an oversight early on. The argument-types that are missing for R1 are:

RL(XLT)
RL(XL~F)
RM(XMT)
RM(XM~F)
RL(XMT)
RL(XM~F)
RM(XLT)
RM(XL~F)

The first four are incorporated into the hierarchy in a fairly straightforward way. I had said that the strongest argument-type in R1 was RL(XT); that was correct of the hierarchies as given, but not of the full hierarchy. The strongest argument-type in R1 is, of course, RL(XLT). RL(XLT) can attenuate either to RL(XL~F) or RL(XT). RL(XL~F), like RL(XT) can attenuate to RL(X~F). Similarly, the weakest argument-type in R1 is not, as I had said, RM(X~F), but RM(XM~F). RM(XT) can attenuate not only to RM(X~F) but also to RM(XMT); and both RM(X~F) and RM(XMT) can attenuate to RM(XM~F).

The other four are rather more complicated. As it turns out, RL(XT) can attenuate to three independent argument-types. Two were those noted in the original hierarchy: RL(X~F) and R(XLT). However, it can also attenuate to RL(XMT). RL(XMT) can attenuate to RL(XM~F) or to R(XMT). It therefore is a shorter path of attenuation from RL(XT) to R(XMT) than that noted in the original hierarchy; it is also certainly independent of the other. RL(X~F) can attenuate to RL(XM~F), which can attenuate to R(XM~F). Similarly, R(XLT) can attenuate to RM(XLT), which is able to attenuate either to RM(XL~F) or RM(XT); R(XL~F) can attenuate to RM(XL~F) as well. RM(XL~F) can attenuate to RM(X~F). I leave it to the interested reader, if there are any interested readers, to work out the look of the hierarchy given these modifications. These patterns of attenuation give the hierarchy a 'three-dimensional' character rather than the two-dimensional character of the hierarchy as I originally presented it.

Preclusion follows the same sort of patterns noted for the incomplete hierarchy.

And, of course, analogous things can be said for all the other hierarchies. Therefore each hierarchy has not ten arguments, as I originally suggested, but eighteen; the four basic hierarchies together involve not forty types of arguments but seventy-two. It just goes to show that a small oversight in the classification system can lead to a massive oversight in things classified.

That correction out of the way, we can turn to the concept of candidacy, and we can motivate our introduction of it in the following way. The strongest argument-type in R1 is a : RaL(XLT). These are arguments in which a is a reason thinking that it is a necessary truth that X is necessarily true. However, not all arguments of this type are of equal strength, because while they all argue for a conclusion of the same strength, they don't all argue on equally strong reasons. Some reasons, even good reasons, for thinking anything a necessary truth are defeasible or probable or plausible. Some rare bases, however, are stronger than this, being such that arguments based on them preclude any counter-argument, even on a different base. (Rigorous demonstrations would be an example.) One way to think of it is that they are cases where an argument based on a is such as to exclude all candidates for counterarguments. It is useful to have a notational option for capturing this. Since we speak of this sort of thing modally, it makes sense to use a modal sign, L, to indicate it; to distinguish it from the other modal signs, it will be standardly placed in front of the R.

Stated in the way I have above, this new L in front of the R is the complement of candidacy: an argument of that type rules out other arguments as being even potential candidates for argument(regardless of base). It makes sense, then, to have a complementary sign, M, which indicates candidacy given a base. That is, it indicates that a is potentially an argument for the conclusion. It too will be placed in front of the R.

It is clear that all LR's can attenuate immediately to plain R's. For instance, a : LRaL(XLT) can attenuate immediately to a: RaL(XLT). It is also clear that any R can attenuate immediately to MR. For instance, a : RaL(XLT) attenuates to a : MRaL(XLT). (Obviously, if an argument is actually made as a good argument, it is a fortiori a candidate for being made as a good argument.) The strengthened hierarchy created by this notation I will refer to as R1+. Similarly strengthenings may be accomplished for all the other hierarchies.

It is important to keep in mind that, while the same modal signs are used in several different positions (in part because we use very similar terms to speak of them, anyway), their positions are important. They do have relations, of course; these are traced out by the attenuation relations of the hierarchy. But they cannot have the same meaning precisely because they are only related to each other by the way they attenuate.

One of the interesting things about candidacy is that it shows something of the relation between the one-base hierarchies that we have been discussing and the multiple-base hierarchies we would sometimes meet. If we have a two-base argument-type:

a,b : Ra(Rb(XT)T)

this is related to:

b : MRb(XT)

The reason is clear; if there is a good argument given a that b is a good argument for XT, it follows that b is a genuine candidate reason for concluding XT. This is not an attenuation relation, because you can go partially in reverse. That is, b : MRb(XT) indicates there is some multiple base argument available for thinking Rb(XT) a good argument; but we don't know what it is. We don't know the bases, and we don't know the structure of the argument. To put it in other words, b : MRb(XT) tells us of the existence of a multiple-base argument, but does not tell us anything about its nature. Since there is a loss of information in moving from a,b : Ra(Rb(XT)T) to b : MRb(XT), but some information is preserved that would not be preserved in an ordinary attenuation relation, we can treat this as a new relation, and call it reduction. Reduction, of course, is key to understanding how multiple-base arguments relate to the simple one-base arguments we have been considering so far. This is a further sign of the value of the strengthened notation, since the strengthening allows us to relate certain kinds of multiple-base argument-types to the one-base hierarchies that could not be related to them without it.

In the next post on this topic I will close by giving a few simple examples showing the typology in action.

No comments:

Post a Comment

Please understand that this weblog runs on a third-party comment system, not on Blogger's comment system. If you have come by way of a mobile device and can see this message, you may have landed on the Blogger comment page, or the third party commenting system has not yet completely loaded; your comments will only be shown on this page and not on the page most people will see, and it is much more likely that your comment will be missed.