ISSA Proceedings 2010 – How Dialogues Create Arguments
The goal of this paper is to demonstrate how argumentation dialogues of various types can construct a shared map or a shared understanding of an issue under discussion. In the language of O’Keefe (1977), the goal is to show how arguments2 create and update arguments1. The approach turns upon two issues. First, that the connection between locutions in a dialogue has an inferential component beyond any that may hold between the contents of those locutions; and second, that the connection between the components of an argument1 and the components of an argument2 is rich and complex – but can be explained by speech act theory. The work is part of a project which aims to build infrastructure for an online ‘Argument Web’ which will support both the analysis, manipulation, assessment and display of billions of arguments1 and also the conduct of millions of concurrent arguments2.
The distinction between argument1 and argument2 originated in an important discussion about the ambiguity of the English word, argument, between W. Brockriede (1975, 1977) and D. J. O’Keefe (1977):
On the one hand it [the word “argument”] refers to a kind of utterance or a sort of communicative act. This sense of the term I will call “argument1”. It is the sense contained in sentences such as “he made an argument.” On the other hand, “argument” sometimes refers to a particular kind of interaction. This sense, “argument2”, appears in sentences such as “they had an argument” (O’Keefe 1977, p. 121).
D. Hitchcock (2006) shows that this ambiguity is not present in other languages:
In classical Greek, for example, the reason-giving sense is expressed by the word logos (e.g. in Plato’s Phaedo, at 90b-91c) in one of its many senses, whereas the disputational sense is expressed by the word amphisbêtêsis or antilogia, “dispute” or “controversy”. In Latin, the reason-giving sense is expressed by the word argumentum, “proof” or “evidence”, the disputational sense by the word disputatio, “debate” or “dispute”. In French, as Plantin (2003: 174) points out in detail, the reason-giving sense is expressed by the verb argumenter (“to argue [that]”) and its cognates, the disputational sense by the verb discuter (“to discuss”, in an aggressive way). In Spanish (Claudio Duran, personal communication), the reason-giving sense is expressed by the word argument, and the disputational sense by the words discusión (discussion) or controversia (controversy) or disputa (dispute). In Russian, the reason-giving sense is expressed by the word dovod (supporting reason), the disputational sense by the word spor or ssora. In German, the reason-giving sense is expressed by the word Argument, the disputational sense by the word Disput. (Hitchcock 2006, p.102).
These two kinds of arguments have different properties, e.g.: arguments1 can be refuted, invalid or fallacious, while arguments2 can be pointless or unproductive (O’Keefe 1977, p. 121).
We want in this paper to explore a little of the connections between the components in argument2, rather more of the relationship between arguments1 and arguments2. For whilst the distinction between argument1 and argument2 is well-known, the connection between them is little understood. After motivating the problem in the next section, sections 3 and 4 provide the pragmatic and computational foundations, and sections 5 and 6 describe how the key challenges are addressed.
Analyzing argumentation in the context of dialogue provides insight into its important properties which are not expressible in a model of monologic argumentation. Firstly, in the real-life practice an argumentation is commonly related to and therefore dependent on a dialogue: “Most often, argument occurs in dialogue. (…) to understand an argument, it is very often highly important to know something about the context of dialogue in which the argument has occurred” (Walton 1990, pp. 411-2). Moreover, the context of a dialogue is especially important, when we want to evaluate the argumentation: “In order to evaluate an argument as correct or incorrect, it is vital to know the context of conversation [i.e. dialogue] in which this argument was used” (Walton 1995, p. 98). Walton describes the case of a television program “Infomercial” as an example of how a dialectical context influences the evaluation of an argument (Walton 1995, pp. 120-3). The infomercial was transmitted on TV as a half-hour talk-show, while in fact it was a commercial. The authors of this program expected to make use of the dialectical shift, i.e. that arguments presented during the infomercial would be evaluated by its viewers in the context of one kind of dialogue, while in fact the other context should be considered. In that case, the program was suggested to be a talk show which assumes the (comparative) objectivity of presented information, while the real context was a sales pitch which presumes one-sided promotion to make a viewer buy some product.
Generally, a lack of distinction between the argument1 and the argument2 may lead to a confusion in argument’s specification and investigation. An example of such confusion was the framework proposed by Brockriede (1975). O’Keefe showed that six characteristics of an argument identified by Brockriede define not one phenomenon, but two different kinds of phenomena: “a confusion of the two senses of argument will obviously turn on a recognition of the differences between arguments1 and arguments2. But Brockriede’s elision of the two senses of ‘argument’ is important, because it is indicative of shifting concerns in the study of argument” (O’Keefe 1977, p. 126).
3. Pragmatic account
We adopt a view of arguments that is rooted in pragmatics. The central notion of pragmatics is the notion of utterance:
Pragmatics deals with utterances, by which we will mean specific events, the intentional acts of speakers at times and places, typically involving language. Logic and semantics traditionally deal with properties of types of expressions, and not with properties that differ from token to token, or use to use, or, as we shall say, from utterance to utterance, and vary with the particular properties that differentiate them. Pragmatics is sometimes characterized as dealing with the effects of context. This is equivalent to saying it deals with utterances, if one collectively refers to all the facts that can vary from utterance to utterance as ‘context’ (Korta & Perry 2006).
In the pragmatic account, an argument would not be a type, but a token. This assumes different levels of abstraction, at which we can look for an argument (see Table 1). At the most abstract level, there are logical schemes such as e.g. Modus Ponens: a, a®b, therefore b, or the scheme from witness testimony (see e.g. Bex et al. 2003): X asserts a, X is in a position to know whether a is true or not, therefore a. Those schemes, however, are not arguments1. One can thus see an argument as an instantiation of a given scheme. Yet an instantiation may be understood in two manners: as a type or a token. The logical accounts treat the argumentation as an argument type. That is, an instantiation of Modus Ponens such as: Harry was in Dundee, If Harry was in Dundee, then he was in Scotland, therefore Harry was in Scotland, is a reasoning or an argument, which properties (such as soundness, validity, etc.) may be analyzed by logical tools. It is, however, still not an argument1 from the pragmatic point of view. The argumentation is the instantiation of a scheme used in a given context, e.g. in a context of a dialogue between Bob and Wilma. That is, an argument1 is a token of the expression “Harry was in Dundee and if Harry was in Dundee, then he was in Scotland, therefore Harry was in Scotland” used (uttered) by Bob e.g. to convince Wilma that Harry was in Scotland. Similarly, a dialogue is not a type, but a token. Both kinds of arguments are real objects that are possessed by some agents (arguers): they are performed by someone (author, sender, proponent, etc.) and addressed to someone (hearer, receiver, opponent, audience, etc.). As Brockriede states: “Arguments are not in statements but in people” (1975, p. 179).
|The level of abstraction||An example|
|Argument scheme||a, a®b,therefore b|
|Argument type||Harry was in Dundee, If Harry was in Dundee, then he was in Scotland,therefore Harry was in Scotland|
|Argument token||Harry was in Dundee and If Harry was in Dundee, then he was in Scotland,therefore Harry was in Scotland,
in the context of a dialogue between Bob and Wilma
Table 1. Different levels of abstraction in argument analysis.
Argument-types may be “retrieved” by means of “abstracting” from a token of argument. That is, if we want to explore a particular argument-type, then any argument-token corresponding to this type can be chosen and considered in isolation from its context (see e.g. (Hitchcock 2006, 107-8) for the discussion on the relation between an argument token and type).
According to the pragmatic theory of speech acts (see e.g. Austin 1962, Searle 1969, Searle & Vanderveken 1985), argumentation is a speech act. A speech act F(p), such as claim(p), why(p), consists of an illocutionary force F and a propositional content p (Searle & Vanderveken 1985). An illocutionary force is related to an intention of uttering a propositional content. That is, the performer of a speech act may utter p with an intention of asserting, arguing, conceding, asking, promising, ordering, warning, and so on.
In general, speech acts are characterized by the locutionary, illocutionary and perlocutionary aspects. A locutionary act is one of performing an utterance. In a dialogue between Bob and Wilma, Bob may e.g. utter that Harry was in Dundee. An illocution is an act of performing an utterance with some force, such as e.g. asserting or questioning. For instance, Bob may utter “Harry was in Dundee” with an intention of informing an audience about Harry’s visit in Dundee or with an intention of explaining e.g. why Harry wasn’t in London at that time. Finally, perlocution is an act of causing an effect by performing the utterance. For example, Bob’s utterance “Harry was in Dundee” may make Wilma regret that they didn’t meet during Harry’s visit in Dundee or make her question Bob’s belief about Harry’s visit in Dundee.
A speech act can be felicitous or infelicitous depending on whether or not it successfully performs a given action. For example, my act of promise that I met you yesterday is infelicitous. The rules that determines what constitutes a successful speech act are called the constitutive rules. Searle (1969) distinguishes four classes of those rules:
– propositional content rules: some illocutions can only be achieved with an appropriate propositional content, e.g. a promise may refer only to what is in the future and under the control of a speaker,
– preparatory rules: they determine what a speaker presupposes in performing a speech act, e.g. a speaker cannot marry a couple unless he is legally authorized to do so,
– sincerity rules: they tell what psychological state is expressed (e.g. an assertion expresses belief, a promise expresses an intention to do something) and a speech act is sincere only if a speaker is actually in this state,
– essential rules: they determine what a speech act consists in essentially, e.g. a promise commits a speaker to perform act expressed in a propositional content.
Thus, my promise that I met you yesterday was infelicitous, since I did not fulfil the propositional content condition (the propositional content does not refer to a future action).
The essential conditions are then used to build a taxonomy of speech acts. Searle distinguishes five classes of speech acts:
– assertives express the speaker’s belief and his desire that the hearer forms a similar one, they also commit the speaker to the truth of the propositional content,
– directives express the speaker’s attitude about a possible future act performed by the hearer and the intention that his utterance be taken as reason for the hearer’s action,
– commissives express the speaker’s intention to do something and the belief that his utterance obliges him to do it, they commit the speaker to do something,
– expressives express feelings toward the hearer, and
– declaratives express that the speaker performs a given action.
Depending on the further characteristics of an illocutionary force, each class divides into various subclasses. For example, assertives split into claim(p), deny(p), guess(p), argue(p), rebut(p), etc.
The illocutionary acts can be divided into two categories with respect to the number of propositional contents that the illocutionary force refers to. First, the illocution may be an instance of a property of a content, such as in the following speech acts: claim(p), why(p) or concede(p). It may also be an instance of a relation between contents (cf. SDRT: Segmented Discourse Representation Theory, Asher & Lascarides 2003). Argumentation can be viewed as an example of the second category of the illocutionary act: argue(p, q). The speech acts may be also divided into simple acts and compound acts containing (constituted from) distinct kinds of acts. The dialogue is an example of the second category: it may be built from consecutive various speech acts. For instance, a dialogue may be a sequence: claim(p); why(p); argue(p, q); concede(p), i.e., the first move in the dialogue is an act of claiming that p holds, what is followed by questioning this claim, what is replied by an argumentation supporting p with q, and the final move is conceding the initial claim.
4. The Need for Unified Computational Representation
Artificial Intelligence has long been an idiosyncratic hybrid of pure theory and practically-oriented engineering. Nowhere is this more true than in computational models of argument. The mathematical theories of argument which originate in works such as (Dung 1995) have been enormously influential in theoretical models of reasoning in AI, because they provide the machinery for handling issues such as defeasibility and inconsistency in ways that traditional classical logics are not able to support. These same mathematical theories are, however, barely recognisable as theories of argumentation as the philosophical and communication scholarly communities would know them. Similarly, highly successful, engineered software tools that support debate and discussion, of which Compendium (Conklin 2005) is a prime example, are rest upon foundations which are both limited and largely unconnected with argumentation proper.
At the same time, AI is also home to applications of theories of informal logic (Gordon et al. 2007), of pedagogic critical thinking (Reed & Rowe 2004), of rhetoric (Crosswhite et al. 2003), of persuasion (Budzynska & Kacprzak, 2008) and of legal argumentation (Walton 2005): these applications are all rooted squarely in the tradition of argumentation theory as a discipline, and diverge from it in ways that are typically incremental and driven by practical necessity. Whilst the fecundity of the research area has been clear (see, e.g., (Rahwan and Simari 2009) for a representative set of papers), the diversity and sheer number of different systems has led, inevitably, to fragmentation.
It was this problem that led in 2005 to a workshop to explore possible means of harmonisation between approaches and systems. The remit of the meeting was avowedly practical: to try to find ways that these systems might start to work together. But practical, engineering issues turn very quickly to deep and open philosophical issues: What constitutes an enthymeme, a fallacy or an inference? What differentiates presumptions and assumptions in argument? How can linguistic and psychological conceptions of argument be reconciled? Are propositions the right atoms from which to construct argumentation complexes? What is the character of the rules that govern argument dialogues? And so on. Clearly, it is impractical to hope that these questions might be resolved once and for all, so the approach is in two parts.
In the first, computational developments are fixed upon what is currently the best understanding of the various issues. This work has also tapped into pragma-dialectics, into speech act theory, and into the work of theorists such as Brockriede, Freeman, Goodwin, Groarke, Hitchcock, Johnson, Kienpointner, Krabbe, O’Keefe, Perelman and Walton amongst many others.
The second part of the approach is to tackle as little as possible at the first iteration – whilst still achieving something significant. For this minimal possible goal, the focus was upon representing arguments. Whilst there are many AI systems that reason with arguments, present arguments, render arguments in natural language, try to understand natural arguments, visualize arguments, navigate arguments, critique arguments, support the construction of arguments, mediate arguments, and so on, we cannot hope to solve problems special to each. It seems reasonable to assume, however, that all of these systems might want to store arguments in some structured format.
If we want to set out to try to support harmonisation between computational systems, and to do so in a way that is as closely tied as possible to current models from the theory of argumentation, then we start with a simple task that is common across most AI systems of argument: representation. In this way, we can aim at a coherent, unified, computational representation. Tackling the representation problem necessitates an understanding of the connection between argument1 and argument2 which is the focus of this paper.
5. Representing arguments
A group of computer scientists have been working to develop a common way of representing arguments for various AI applications (Chesnevar et al. 2006). It aims to harmonise the strong formal tradition initiated to a large degree by Dung (1995), the natural language research described at CMNA workshops since 2000 (see www.cmna.info), and the multi-agent argumentation work that has emerged from the philosophy of Walton and Krabbe (1995), amongst others.
The approach can be seen as a representation framework constructed in three layers. At the most abstract layer, it provides a hierarchy of concepts which can be used to talk about argument structure. This hierarchy describes an argument by conceiving of it as a network of connected nodes that are of two types: (1) information nodes that capture data (such as datum and claim nodes in a Toulmin analysis, or premises and conclusions in a traditional analysis), and (2) scheme nodes that describe passage between information nodes (similar to the application of warrants or rules of inference). Scheme nodes in turn come in several different guises, including (2i) scheme nodes that correspond to support or inference (or rule application nodes), (2ii) scheme nodes that correspond to conflict or refutation (or conflict application nodes), and (2iii) scheme nodes that correspond to value judgements or preference orderings (or preference application nodes). At this topmost layer, there are various constraints on how components interact: information nodes, for example, can only be connected to other information nodes via scheme nodes of one sort or another. Scheme nodes, on the other hand, can be connected to other scheme nodes directly (in cases, for example, of arguments that have inferential components as conclusions, e.g. in patterns such as Kienpointner’s (1992) “warrant-establishing arguments”). The approach also provides, in the extensions developed for the Argument Web (Rahwan et al. 2007), the concept of a “Form” (as distinct from the “Content” of information and scheme nodes). Forms allow the representation of uninstantiated definitions of schemes (this has practical advantages in allowing different schemes to be represented explicitly – such as the very rich taxonomies of Walton et al. (2008), Perelman and Olbrechts-Tyteca (1969), Grennan (1997), etc. – and is also important in law, where arguing about inference patterns can become important).
A second, intermediate layer provides a set of specific argumentation schemes (and value hierarchies, and conflict patterns). Thus, the uppermost layer specifies that presumptive argumentation schemes are types of rule application nodes, but it is the intermediate layer that cashes those presumptive argumentation schemes out into Argument from Consequences, Argument from Cause to Effect and so on. At this layer, the form of specific argumentation schemes is defined: each will have a conclusion description (such as “p may plausibly be taken to be true”) and one or more premise descriptions (such as “E is an expert in domain D”). It is also at this layer that, as Rahwan et al. (2007) have shown, critical questions are handled. In addition to descriptions of premises and conclusions, each presumptive inference scheme also specifies descriptions of its presumptions and exceptions. Presumptions are represented explicitly as information nodes, but, as some schemes have premise descriptions that entail certain presumptions, the scheme definitions also support entailment relations between premises and presumptions following (Gordon et al. 2007).
Finally the third and most concrete level supports the integration of actual fragments of argument, with individual argument components (such as strings of text) instantiating elements of the layer above. At this third layer an instance of a given scheme is represented as a rule application node, and the terminology now becomes clearer. This rule application node is said to fulfil one of the presumptive argumentation scheme descriptors at the level above. As a result of this fulfilment relation, premises of the rule application node fulfil the premise descriptors, the conclusion fulfils the conclusion descriptor, presumptions can fulfil presumption descriptors, conflicts can be instantiated via instances of conflict schemes that fulfil the conflict scheme descriptors at the level above, and so on. Again, all the constraints at the intermediate layer are inherited, and new constraints are introduced by virtue of the structure of the argument at hand.
6. Connecting argument1 and argument2
The next step is to extend our account to handle not just argument1 but also dialogic argumentation in argument2. In real-life scenarios, both kinds of argument coexist and interact with each other. Imagine the following dialogue between Bob and Wilma (i.e. an argument2):
Bob: You know what? Harry was in Dundee.
Wilma: How do you know?
Bob: I saw him.
In this dialogue, Bob and Wilma jointly build argumentation structure (an argument1): Harry was in Dundee, since Bob saw him in Dundee. Observe that Bob’s utterance “Harry was in Dundee” could be left without justification (i.e. without forming an argument), if Wilma did not question it, i.e. if she did not express doubts whether it is true or false (or whether to accept it or not). In other words, the dialogue triggers the argumentation. Moreover, the context of the argument2 enables keeping track of the agents’ interaction which creates the argument1: argumentation is invoked (the broken-line arrow in Fig. 1) by Wilma’s speech act, and provided (the solid-line arrow in Fig. 1) by Bob’s speech acts. Representing both argument1 and argument2 in a coherent framework, however, presents significant challenges. Several preliminary steps have been taken to extend computational representation in the style of section 5 to tackle these challenges (Reed 2006), (Modgil & McGinnis 2008) and (Reed et al. 2008). But these approaches do not adequately address the links between argument1 and argument2. For clearly there are many links between argument1 and argument2, in that the steps and moves in the latter are constrained by the dynamic, distributed and inter-connected availability of the former, and further, in that valid or acceptable instances of the former can come about through sets of the latter. An understanding of these intricate links which result from protocols, argument-based knowledge and performance of speech acts demands a representation that handles both argument1 and argument2 coherently. It is this that we need to provide here.
The background framework for the argument1 is logic (see Table 2). However, its meaning is adjusted to the pragmatic approach as described in Section 3. Consequently, argument1 is interpreted as an instance (token) of reasoning. The basic type of units that describes argument1 are built from propositions which may refer to any situation. They can describe someone’s speech act (e.g. Bob’s assertion that Harry was in Dundee) as well as to any other action or situation (e.g. Harry’s presence in Dundee). The main types of relations between those units can be based on deductive rules (e.g. on Modus Ponens: Harry was in Dundee and If Harry was in Dundee, then he was in Scotland, therefore Harry was in Scotland), on defeasible rules such as argumentation schemes (e.g. on appeal to witness testimony: Bob asserts that Harry was in Dundee and Bob is in a position to know whether Harry was in Dundee, therefore Harry was in Dundee), or on rules for conflicts (e.g. a logical conflict among a proposition and its negation: Harry was in Dundee and Harry wasn’t in Dundee).
|Background||Types of units||Main relations|
|argument1||Logic||propositions describing the world (in particular – locutions)||– deductive rules (e.g. Modus Ponens)- argumentation schemes (e.g. appeal to witness testimony)
– conflicts (e.g. logical contradiction)
|argument2||Dialectics||propositions describing locutions||– dialogue rules (e.g. protocols for PPD0)|
|Connection between arg1 and arg2||Pragmatics||elements of arg1 and arg2||– illocutionary schemes (e.g. constitutive rules for assertion)|
Table 2. The properties of arguments and their connections.
Argument2 has a dialectical interpretation. The basic type of units that describes argument2 are built from propositions restricted to refer to speech acts. The fundamental building blocks of dialogues are called individual locutions. In the context of the approach in Section 5, Modgil and McGinnis (2008) have proposed modelling locutions as information nodes. We follow this approach primarily because statements about locution events are propositions that could be used in arguments. So for example, the proposition, Chris says, ‘ISSA will be in Amsterdam’ could be referring to something that happened in a dialogue (and in a moment we shall see how we might therefore wish to reason about the proposition, ISSA will be in Amsterdam) – but it might also play a role in another, monologic argument (say, an argument from expert opinion, or just an argument about Chris’ communicative abilities).
Associating locutions exactly with information nodes, however, is insufficient. There are several features that are unique to locutions, and that do not make sense for propositional information in general. Foremost amongst these features is that locutions often have propositional content. The relationship between a locution and the proposition it employs is, as Searle (1969) argues, constant – i.e. “propositional content” is a property of (some) locutions. Whilst other propositions, such as might be expressed in other information nodes, may also relate to further propositions, (e.g. the proposition, It might be the case that it will rain) there is no such constant relationship of propositional content. On these grounds, we should allow representation of locutions to have propositional content, but not demand it for information nodes in general – and therefore the representation of locutions should form a subclass of information nodes in general. We call this subclass, “locution nodes”. There are further reasons for distinguishing locution nodes as a special case of information nodes, such as the identification of which dialogue(s) a locution is part of. (There are also some features which one might expect to be unique to locutions, but on reflection are features of information nodes in general. Consider, for example, a time index – we may wish to note that Chris said, ‘ISSA will be in Amsterdam’ at 10am exactly on the 1st March 2010. Such specification, however, is common to all propositions. Strictly speaking, the sentence, It might be the case that it will rain, is only a proposition if we spell out where and when it holds. In other words, a time index could be a property of information nodes in general, though it might be rarely used for information nodes and often used in locution nodes).
Given that locutions are (a subclass of) information nodes, they can, like other information nodes, only be connected through scheme nodes. The types of relations between those units are based on dialogue rules (e.g. on a protocol for the system PPD0; for instance, the protocol demands that a move claim(p) can be followed either by why(p) or by concede(p) (see e.g. (Prakken 2000)). There is a direct analogy between the way in which two information nodes are inferentially related when linked by a rule application, and the way in which two locution nodes are related when one responds to another by the rules of a dialogue. Imagine, for example, a dialogue in which Chris says, ‘ISSA will be in Amsterdam’ and Katarzyna responds by asking, ‘Why is that so?’. In trying to understand what has happened, one could ask, ’Why did Katarzyna ask her question?’. Now although there may be many motivational or intentional aspects to an answer to this question, there is at least one answer we could give purely as a result of the dialogue protocol, namely, ‘Because Chris had made a statement’. That is to say, there is plausibly an inferential relationship between the proposition, ‘Chris says ISSA will be in Amsterdam’ and the proposition, ‘Katarzyna asks why it is that ISSA will be in Amsterdam’. That inferential relationship is similar to a conventional inferential relationship, as captured by a rule application. Clearly, though, the grounds of such inference lie not in a scheme definition, but in the protocol definition. Specifically, the inference between two locutions is governed by a transition, so a given inference is a specific application of a transition. Hence we call such nodes transition application nodes, and define them as a subclass of rule application nodes. (Transition applications bear strong resemblance to applications of schemes of reasoning based on causal relations: this resemblance is yet to be further explored, but further emphasises the connection between inference and transition).
So, in just the same way that a rule application fulfils a rule of inference scheme form, and the premises of that rule application fulfil the premise descriptions of the scheme form, so too, a transition application fulfils a transitional inference scheme form, and the locutions connected by that transition application fulfil the locution descriptions of the scheme form. The result is that all of the machinery for connecting the normative, prescriptive definitions in schemes with the actual, descriptive material of a monologic argument is re-used to connect the normative, prescriptive definitions of protocols with the actual, descriptive material of a dialogic argument. With these quick introductions, the upper level of this model is almost complete.
One final interesting piece of the puzzle is how, exactly, locution nodes are connected to information nodes. So for example, what is the relationship between a proposition p and the proposition: X asserted p? According to the original specification, direct links between information nodes are prohibited (and with good reason: to do so would introduce the necessity for edge typing – obviating this requirement is one of the computational advantages of the approach). The answer to this question is already available in the work of Searle (1969) and later with Vanderveken (Searle & Vanderveken 1985). The link between a locution (or, more precisely, a proposition that reports a locution) and the proposition (or propositions) to which the locution refers is one of illocution. The illocutionary force of an utterance can be of a number of types (see Section 3) and can involve various presumptions and exceptions of its own. In this way, it bears more than a passing resemblance to scheme structure. These schemes are not capturing the passage of a specific inferential force, but rather the passage of a specific illocutionary force. As a result, we refer to these schemes as illocutionary schemes. These schemes encapsulate constitutive rules for performing speech acts (see Section 3). The constitutive rules can be of a number of types depending on the type of illocutionary force which the performer of the speech act assumes. Specific applications of these schemes are then, following the now familiar pattern, illocutionary applications. To keep concepts distinct where in natural language we are often rather sloppy, we adopt the naming convention by which illocutionary schemes are referred to with gerunds (asserting, promising, etc.), whilst transitional inference schemes are referred to with nouns (response, statement, etc.), which both ensures clarity in nomenclature, and is also true to the original spirit and many of the examples in both the Speech Act and Dialogue Theory literatures.
The focus of this paper has been upon trying to develop an initial understanding of the connection between argument1 and argument2 and to do so in a way that is amenable to subsequent computational interpretation. To do this, the paper has reviewed just enough of the machinery of the computational representation approach to allow the reader to get a clear understanding of the philosophical masts to which it is nailing its colours. The extensions that support dialogue lean heavily on commitment-based models of dialogue developed by Walton, Woods, Mackenzie and others. There have been many examples of generalised machine-representable dialogue protocols and dialogue histories, e.g. (Robertson 2005), but these approaches do not make it easy to identify how the interactions between dialogue moves have effects on structures of argument (i.e. argument1), nor how those structures constrain dialogue moves during argument (i.e. argument2). Though there are still challenges of expressivity and flexibility, we have offered a foundation for representing complex protocols and rich argument structures, and have shown that the ways in which those protocols govern or describe dialogue histories is directly analogous to the ways in which schemes govern or describe argument instances. These strong analogies provide representational parsimony and simplify implementation. This is important because computational representations are far too detailed to create by hand, and the range of software systems that use them will stretch from corpus analysis to agent protocol specification, from Contract Net (Smith 1980) through agent ludens games (McBurney & Parsons 2002) to PPD0 (Walton & Krabbe 1995). The success of the approach will be measured in terms of how well such disparate systems work together. As the argument web starts to become a reality, the diversity of applications and users will place enormous strain on the representational adequacy of the infrastructure, so it is vital that that infrastructure rests upon a solid foundation.
Asher, N., & Lascarides, A. (2003). Logics of Conversation. Cambridge: Cambridge University Press.
Austin, J. L. (1962). How to Do Things with Words. Oxford: Clarendon.
Bex, F.J., Prakken, H., Reed, C., & Walton, D.N. (2003) Towards a formal account of reasoning about evidence: argumentation schemes and generalisations. Artificial Intelligence and Law, 11, 125 – 165.
Brockriede, W. (1975). Where Is Argument? Journal of the American Forensic Association, 11, 179-182.
Brockriede ,W. (1977). Characteristics of Arguments and Arguing. Journal of the American Forensic Association, 13.
Budzynska, K., & Kacprzak, M. (2008). A Logic for Reasoning about Persuasion. Fundamenta Informaticae, 85, 51-65.
Chesñevar, C., McGinnis, J., Modgil, S., Rahwan, I., Reed, C., Simari, G., et al. (2006). Towards an Argument Interchange Format. Knowledge Engineering Review, 21, 293-316.
Conklin, J. (2005). Building a Dialogue Mapping: Building Shared Understanding of Wicked Problems. John Wiley & Sons.
Crosswhite, J., Fox, J., Reed, C., Scaltsas, T., & Stumpf, T. (2003). Computational Models of Rhetorical Argument. Argumentation Machines: New Frontiers in Argument and Computation, 175-209.
Dung, P. (1995). On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and N-Person Games. Artificial Intelligence, 77, 321-358.
Gordon, T., Prakken, H., & Walton, D. (2007). The Carneades model of argument and burden of proof. Artificial Intelligence, 171, 875-896.
Grennan, W. (1997) Informal Logic. McGill Queens University Press.
Hitchcock, D. (2006). Informal logic and the concept of argument. In D. Jacquette (Ed.), Philosophy of Logic, volume 5 of D. M. Gabbay, P. Thagard & J. Woods (Eds.), Handbook of the Philosophy of Science (pp. 101-129). Elsevier.
Kienpointner, M. (1992). How to Classify Arguments. In F. van Eemeren, R. Grootendorst, J. Blair & C. Willar (Eds.), Argumentation Illuminated (pp. 178-188). Amsterdam: Sic Sat.
Korta, K., & Perry, J. (2006). Pragmatics. In E. N. Zalta (Ed.), Stanford Encyclopedia of Philosophy, Center for the Study of Language and Information, Stanford University.
McBurney, P., & Parsons, S. (2002). Games that agents play: A formal framework for dialogues between autonomous agents. Journal of Logic, Language and Information, 11, 315-334.
O’Keefe, D. J. (1977). Two concepts of argument. Journal of the American Forensic Association, 13, 121-128.
Modgil, S., & McGinnis, J. (2008). Towards Characterising Argumentation Based Dialogue in the Argument Interchange Format. Proceedings of the 4th International Workshop on Argumentation in Multi-Agent Systems (ArgMAS2007), Springer.
Perelman, C., & Olbrechts-Tyteca, L. (1969). The New Rhetoric: A Treatise on Argumentation. University of Notre Dame Press.
Prakken, H. (2000). On dialogue systems with speech acts, arguments, and counterarguments. Proceedings of JELIA’2000, The 7th European Workshop on Logics in Artificial Intelligence. Springer Lecture Notes in AI 1919, 224-238.
Prakken, H. (2005). Coherence and flexibility in dialogue games for argumentation. Journal of Logic and Computation, 15, 1009-1040.
Rahwan, I., Zablith, F., & Reed, C. (2007). Laying the Foundations for a World Wide Argument Web. Artificial Intelligence, 171, 897-921.
Rahwan, I., & Simari, G. (2009). Argumentation in Artificial Intelligence, Springer.
Reed, C. (2006) Representing Dialogic Argumentation. Knowledge Based Systems, 19, 22-31.
Reed, C., & Rowe, G. (2004). Araucaria: Software for Argument Analysis, Diagramming and Representation. International Journal of AI Tools, 14, 961-980.
Reed, C., Wells, S., Devereux, J., & Rowe, G. (2008). AIF+: Dialogue in the Argument Interchange Format. In P. Besnard, S. Doutre, & A. Hunter (Eds.), Computational Models of Argument: Proceedings of COMMA-2008 (pp. 311-323). IOS Press.
Robertson, D. (2005). A Lightweight Coordination Calculus for Agent Systems, in Declarative Agent Languages and Technologies II, Springer, 183-197.
Searle, J. (1969). Speech Acts: An essay in the philosophy of language. Cambridge: Cambridge University Press.
Searle, J., & Vanderveken, D. (1985). Foundations of Illocutionary Logic. Cambridge: Cambridge University Press.
Smith, R. (1980). The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver. IEEE Transactions on Computers C-29, 1104-1111.
Walton, D. (1990). What is reasoning? What is an argument? The Journal of Philosophy, 87, 399-419.
Walton, D. (1995). A Pragmatic Theory of Fallacy. The Univ. of Alabama Press.
Walton, D. (2005). Argumentation methods for artificial intelligence in law. Springer.
Walton, D., & Krabbe, E. (1995). Commitment in Dialogue. SUNY Press.
Walton, D., Reed, C., & Macagno, F. (2009). Argumentation Schemes. Cambridge University Press.