Abstract
Argumentation Frameworks (AFs) provide a fruitful basis for exploring issues of defeasible reasoning. Their power largely derives from the abstract nature of the arguments within the framework, where arguments are atomic nodes in an undifferentiated relation of attack. This abstraction conceals different senses of argument, namely a single-step reason to a claim, a series of reasoning steps to a single claim, and reasoning steps for and against a claim. Concrete instantiations encounter difficulties and complexities as a result of conflating these senses. To distinguish them, we provide an approach to instantiating AFs in which the nodes are restricted to literals and rules, encoding the underlying theory directly. Arguments in these senses emerge from this framework as distinctive structures of nodes and paths. As a consequence of the approach, we reduce the effort of computing argumentation extensions, which is in contrast to other approaches. Our framework retains the theoretical and computational benefits of an abstract AF, distinguishes senses of argument, and efficiently computes extensions. Given the mixed intended audience of the paper, the style of presentation is semi-formal.
Introduction
Abstract Argumentation Frameworks (AFs) (Dung, 1995) provide a fruitful basis for exploring issues of defeasible reasoning. Their power largely derives from the abstract nature of the arguments within the framework, where arguments are atomic nodes in an undifferentiated relation of attack; such AFs provide a very clean acceptability semantics (Dung, 1995; Dunne & Bench-Capon, 2002).
While abstract approaches facilitate the study of arguments and the relations between them, it is necessary to instantiate arguments to apply the theory.1
In alternative terminology, we may say to structure arguments, which we use interchangeably.
The semantics of these inference rules, consistent with the literature on logic programming (Gelfond & Lifschitz, 1988), is different from the material implication of classical logic in the sense that they are not ‘contrapositive’ (e.g.
In addition, by exploiting argumentation techniques, we can reason with inconsistent knowledge bases (KBs) and derive consistent subsets of the KB. Such techniques are not novel in the literature (Besnard & Hunter, 2008; Bondarenko, Dung, Kowalski, and Toni, 1997; Brewka & Woltran, 2010; Caminada & Amgoud, 2007; García & Simari, 2004; Prakken, 2010), but for the sake of the discussion we will consider the Argumentation Service Platform with Integrated Components (ASPIC) (Caminada & Amgoud, 2007) only.
Over the course of the paper, we will show that although ASPIC is rather general (in comparison to the proposed approach), there are some drawbacks. First, restricting ASPIC to adhere to the tertium non datur principle in order to have automatic what-if scenarios would require additional rules to be explicitly included in the KB. Although this might be desirable, it increments the complexity of the overall framework. The approach proposed here does not require such additional rules.
Second, in order to satisfy the rationality postulates (Caminada & Amgoud, 2007), ASPIC requires a priori choices to be made (e.g. restricted rebut and preferred semantics vs. unrestricted rebut and grounded semantics). In this work, we derive straightforwardly a multiple-status semantics – basically preferred semantics with an additional requirement – which provides us with rational outcomes.
Finally, before applying argumentation semantics, ASPIC derives a set of arguments which are not atomic entities: each argument can be subargument of a second argument; therefore, an attack against the first reflects as an attack against the second as well. This paradigm of nesting arguments inside other arguments has been proved to be very powerful and flexible, but in this paper we show an easier way to construct atomic abstract arguments – in a one-to-one correspondence with propositions and rules – and attacks among them (Dung, 1995) so to compute the derived conclusions without the need of nesting rules – under our operative constraints discussed above.
Our argument construction paradigm allows us not only to exploit computational properties of Dung's AFs (1995), but it gives us an insight of the different terminological meanings of the word argument: (i) a one-step reason for a claim (Argument with capital ‘A’); (ii) a chain of reasoning leading towards a claim (Case); and (iii) reasons for and against a claim (Debate). By adopting the proposed approach for representing a KB, these three senses of the word argument have a direct and clear counterpart in the graph: each of them is a subgraph with specific characteristics. Although this has not an immediate effect on the computation of extensions, it can provide a useful linkage between the community of computational models of arguments and more philosophical approaches to argument representation and reasoning in less formal – although not less rigorous – contexts (Hoffmann, 2005; Laronge, 2009). Indeed, legal reasoning widely uses the tertium non datur principle – that is, John is either guilty or innocent – thus making it an interesting domain to explore. To this aim, the paper is deliberately written in ‘semi-technical’ way: we have been rigorous in definitions and properties discussion, but we have made the discussion available even beyond the argumentation in artificial intelligence community. Future work will be more focused on each of the two communities.
The structure of the paper is as follows. In Section 2, we outline the AFs of Dung (1995) and the instantiated argumentation of Caminada and Amgoud (2007), which for the purpose of this work are equivalent. In Section 3, we characterise the types of KB we are working with, then show how a KB is represented in a derived AF. We illustrate the approach with basic examples of the definitions, a simple example of a combination of strict and defeasible rules, and the relationship of extensions to classical logic models. The different senses of argument are then characterised in terms of particular structures within the AF as presented in Section 4. In Section 5, we discuss various aspects of the proposal: we compare it to the approach to KB instantiation of Caminada and Amgoud (2007) along with key examples; consider other approaches to KB instantiation; and outline a range of additional strengths. We conclude in Section 6 with some remarks and future work.
In this section, we briefly outline abstract and instantiated argumentation.
Abstract argumentation (Dung, 1995)
An AF is defined as follows (Dung, 1995).
An AF is a pair
The relevant auxiliary definitions are as follows, where
We say that
There are a variety of other semantics, for example, grounded, stable, and others (see Baroni, Caminada, and Giacomin, 2011 for an introduction), but for our purposes, we only consider preferred extensions (Dung, 1995).
As it is our intention to clarify the notion of argument itself, we want to use content neutral terminology in the expression of the syntax rather than relying on terminology such as argument and attacks, which introduce semantic interpretations. Thus, we usually refer to the so-called arguments of AFs defined above as graph-theoretic nodes (denoted by
In this section, we briefly review the key components of the benchmark argument instantiation method ASPIC (Caminada & Amgoud, 2007), which we later exemplify and compare to our proposal.
In constructing arguments, several functions are introduced:
Argument
Suppose a Theory Base,
Such a system determines the acceptability status of propositions generally in three steps as in Figure 1 (from Caminada & Wu, 2011). Starting with an inconsistent KB comprised of facts and rules, we construct arguments (nodes) and attacks (arcs) from this KB, resulting in an AF (Step 1); evaluate the AF according to a variety of semantics, resulting in extensions (sets) of arguments (Step 2); and extract the conclusions from the arguments, resulting in extensions of conclusions (Step 3). Thus, from a KB that is initially inconsistent (or derives inconsistency), we can nonetheless identify consistent sets of propositions.
Three steps of argumentation.
In Section 5.1, we provide an example of a KB and arguments as generated using ASPIC.
In this section, we introduce our approach in two parts (the presentation is a revision of Wyner et al., 2009, 2013). In the first part, we represent a Theory Base
Theory Base
A Theory Base,
We have a set of proper names of rules
We refer to the literals in bd(r) as premises and the literal in hd(r) as the claim.
For easy reference to the ‘content’ of the rule, we assume each rule has an associated definite description as follows. For
We constrain a Theory Base, which we refer to as a Well-formed Theory, with the following Constraints 1–4. The purpose of the constraints is to reduce the expressivity of the language that appears in the Theory Base, guiding the knowledge engineer to produce a sound formalism. The first two constrain the relation of literals and rules; the third constrain reuse of literals between strict and defeasible rules; while the fourth prohibits strictly asserted contradiction.
First, every literal appears in some rule.
For Theory Base
In addition, every rule has a claim.
For Theory Base
Furthermore, the relationship between literals of strict and defeasible rules is constrained such that a strict rule is not, in effect, ‘contained within’ a defeasible rule:
For Theory Base
Finally, no literal and its negation can both be strictly asserted.
For Theory Base
Given these constraints, we have the following:
A Well-formed Theory,
For the semantics, we assume standard notions of truth and falsity of literals. For the difference between strict and defeasible rules, we use quantification over circumstances (Lewis, 1975). Semantically, a rule
While the clauses are similar to the Horn Clauses of logic programming, the head literal can be in a positive or negative form. We only have classical negation, not negation as failure; we do not allow iterated negation – that is,
A core element of our approach is the concept of the AF derived from a Theory Base. The AF uses a set of labels for the nodes in the graph:
Syntax of derivation
In an AF
The set of attacks of an AF
Let
The derived AF from
In the following, we provide the semantic notions for an AF Each literal y in Each rule in r in For strict rules, if a node which corresponds to the negation of a body literal of a rule is in an admissible set, we say the rule node has not been applied relative to that set. In this case, the node which corresponds to the head literal is only credulously admissible. If all the nodes which correspond to the body literals are in an admissible set, then the rule node has been applied and the node which corresponds to head literal is admissible in that set. For defeasible rules, if a node which corresponds to the negation of a body literal or if the node which corresponds to the negation of the head literal of the rule is in an admissible set, we say the rule node has not been applied relative to that set. In both instances, the node corresponding to the literal attacks the rule node. Even if all nodes which correspond to the body literals of a rule are in an admissible set, the rule node or the node which corresponds to the head literal may not be in that set, for they can be defeated.
Given a derived AF
For our purposes and relative to our classical logic context, the set of extensions provided by Dungian AFs must be filtered. In our approach, AFs are derived from a Theory Base, and the resulting extensions are not homogeneous, for they may contain both literals and rules. More importantly, we must ensure that the extensions also serve to satisfy classical logic properties such as closure under strict implication. With these points in mind, we have the following, where Constraint 5 ensures closure under strict implication. Note that the constraint does not apply to defeasible rules, as we discuss further below.
Consider a, a set that is a preferred extension in the derived AF
We can now introduce the concept of Well-formed Preferred Extension (WFPE), namely a preferred extension satisfying the above constraint. It is worth mentioning that, in general, a preferred extension (Dung, 1995) is not a WFPE, but a WFPE is always a preferred extension.
A preferred extension of the derived AF
The implication is that relative to WFPEs, for
To this point, we have Theory Bases, corresponding derived AFs, and constraints on extensions. Fundamental observations of our approach are:
For the literals and the rules which are true in every model for the Theory Base
For the literals and the rules which are false in any model of a Theory Base
Both of these follow by the evaluation of a derived framework
We now give some examples of the basic definitions, discuss defeasibility, provide a simple combination of strict and defeasible rules, illustrate reasoning with an assertion in a partial KB, and comment on the connection between the extensions and the classical models. In Section 5, we discuss examples from the literature, which have been discussed as problematic for an ASPIC-type approach, but are unproblematic in the approach presented above.
First, we provide a Theory Base
Let
We graphically represent AF of 
In
We observe that the WFPEs with respect to an AF correlate with the models of the Theory Base; in this respect, the derived AF is a means to build models for the Theory Base. This observation applies to strict and defeasible rules alike (Section A.3).
The following is an example of a defeasible rule.
Let
We graphically represent the derived AF AF of AF derived from 

In
The first three preferred extensions are similar to those for a strict rule. In the last extension,
Therefore, to make use of a defeasible rule, one must provide the means to choose between extensions, for example, by selecting the extension which maximises the number of applicable defeasible rules, or which uses some notion of priority or entrenchment on the rules. Different ways of making this choice give rise to different varieties of non-monotonic logic (Prakken & Sartor, 1997; Reiter, 1980). Circumscription (McCarthy, 1980) could be used by including additional designated nodes such as
In our third example, we show the interaction of defeasible and strict rules, which was the root of several of the problems identified in Caminada and Amgoud (2007).
Suppose
AF
In Section 3, we defined AFs for derived theory bases and provided several examples. In this section, we formalise the three senses of argument in this language, introduced in Section 1, which we believe have been conflated in the literature. These senses can be formally articulated in our framework as distinct structures. As discussed in Section 1, the term argument is ambiguous (Wyner, Bench-Capon, & Atkinson, 2008), and arguments in a legal setting provide examples. It can mean the reasons for a claim given in one step (an Argument); or it can mean a train of reasoning leading towards a claim (a Case), that is, a set of linked Arguments; or it can be taken as reasons for and against a claim (a Debate), that is, a Case for the claim and a Case against the claim. An additional structure is where the intermediate claims of the Debate are also points of dispute, but we will not consider this further here. In the following, we formally define these three senses of argument as structures in the AF, starting with Arguments, then providing Cases, and finally Debates. We provide a graphic, examples, and then definitions for the three different kinds of attack: Rebuttal, Undercutting, and Undermining.
We provide a recursive, pointwise definition of a graph which is constructed relative to an AF. Since the sets are constructed relative to a derived AF, we can infer the attack relations which hold among them. The different senses of argument are defined as subgraphs. The definition is exercised in Example 4 along with Figure 5.
Arguments, cases, and single-point debates. Suppose there is a derived AF with respect to Theory Base 
Supposing a derived AF,
Suppose an AF derived from Theory Base
We define For all There is exactly one
Note that
Turning to the concept of Case for y
Where we have
Suppose two derived AFs,
Clearly a debate with subsidiary debates can be constructed to argue pro and con about other literals in the base debate; we start with a
Example 4 shows the senses in a derived AF only with strict rules since they restrict the available preferred extensions.
Suppose a Theory Base comprised of the rules (and related literals):
In Figure 5, we have three subgraphs which represent an Argument; each Argument is derived from the corresponding rule of the Theory Base. For example
Given these structures we can express the various familiar notions of attack on an argument: a Undermining of an Argument is an Argument with claim that is the negation of the premise of another Argument; a Rebuttal of an Argument is an Argument with a claim that is the negation of the claim of another Argument; the Rebuttal of a Case is similar to the Rebuttal of an Argument; and an Undercutter of an Argument is an attacker of the rule node of an argument.
Suppose an AF derived from Theory Base
Given the definitions of the three senses of ‘argument’ and various notions of attack, it would be possible to define a more abstract, derivative AF in which we represent structures at levels
So far we have only PRules in a Single-point Debate. Usually in a Theory Base there are assertions which further restrict the preferred extensions. In our framework, assertions are ARules. A Case such as Arg
Discussion
In this section, we compare our approach to ASPIC, discuss other approaches, and then outline several additional advantages.
Comparison to ASPIC with a base-case example
In this section, we exemplify the differences between our approach and ASPIC. In Section 5.1.1, we show how the ex falso quodlibet and the tertium non datur are automatically satisfied by our approach, while they require additional rules in ASPIC. Section 5.1.1 provides an example from Caminada and Amgoud (2007), which highlights an issue in the instantiation method of ASPIC (Caminada and Amgoud, 2007) (see Section 2.2) as well as motivates the Rationality Postulates. We then show how such problems do not arise in our approach.
Credulous reasoning
Let us consider a Theory Base
ASPIC constructs the following three arguments:
Instead, using the approach described in Section 3, the resulting framework is shown in Figure 6.
Credulous reasoning.
In particular, the shown framework has two WFPEs, namely
To obtain the same extensions using ASPIC,
Thus, as pointed out in the introduction, ASPIC requires auxiliary rules that our approach does not.
Consider a Theory Base with strict and defeasible rules from which we construct arguments according to the definitions of ASPIC (Caminada & Amgoud, 2007) outlined in Section 2.2. We examine Example 5 of Caminada and Amgoud (2007).
Let
We see clearly that arguments can have subarguments: A
Several additional elements are needed to define justified conclusions. An argument is strict if it has no defeasible subargument, otherwise it is defeasible (non-strict). An argument A
With respect to the example, Caminada and Amgoud (2007) claim that the justified conclusions are
In our view, these notions of argument and defeat are problematic departures from Dung (1995), which has no notion of subargument or of defeat in terms of subarguments. In addition, they give rise to the problems with justified conclusions: what is a strict rule in the Theory Base can appear in the AF as a non-strict argument in virtue of subarguments; what cannot be false in the Theory Base without contradiction is defeated in the AF; thus, what ‘ought’ to have been a justified conclusion is not. In addition, the notion of justified conclusion leads to some confusion: on the one hand, it only holds for sceptically accepted arguments, which presumably implies that the propositions which constitute them are sceptically accepted; on the other hand, there is no reason to expect that
In our approach, the results are straightforward and without anomaly; we do not make use of arguments with subarguments, inheritance of defeasiblity, or problematic notions of justified conclusions. We consider a key example from Caminada and Amgoud (2007) as the two other problematic examples cited in Caminada and Amgoud (2007) follow suit. The Theory Base of Example 5 appears as in Figure 7, for which all the preferred extensions for the AF are given. For clarity and discussion, we include undefeated strict and defeasible rules.
Graph of problem example.
Notice that WFPEs (1)–(3) are unproblematic with respect to consistency and closure. They also satisfy Definition 7, so are the relevant extensions to consider. In contrast, extension (4) is problematic in an argumentation theory without Definition 7 since the conclusions of strict rules are missing, thus violating closure. Yet, (4) does not satisfy Constraint 5: the premises and rule nodes of strict rules are present, but the conclusions are not. With respect to those extensions that satisfy Definition 7,
We have considered a widely adopted approach to instantiating Theory Bases in AFs (Caminada & Amgoud, 2007) along with the problems that arise. There are other approaches to instantiating a KB in an AF that may avoid problems with the Rationality Postulates such as Assumption-based (Bondarenko et al., 1997) or Logic-based (Besnard & Hunter, 2008) argumentation. However, these approaches, like the ASPIC approach, follow the three-step structure of Figure 1; we leave further comparison and contrast to future work.
Here we comment briefly on a closely related proposal (Strass, 2013) set in the different approach of Abstract Dialectical Frameworks (ADF) (Brewka & Woltran, 2010), which is presented as a generalisation of Dungian AFs but also as a means to represent instantiated arguments, for example, logic programs (Brewka and Woltran, 2010). Broadly, we may distinguish between approaches based on Dung (1995) that make use of nodes (arguments) and arcs (attacks) alone to determine extensions and those which use auxiliary conditions to specify extensions with respect to successful attacks such as preferences (Prakken, 2010) or values (Bench-Capon, 2003). The approach of Brewka and Woltran (2010) is a generalisation of the latter approach: in addition to nodes (which can be statements or literals) and links (generalised from arcs as attacks), there are acceptance conditions, which are functions for each statement from its parents (those nodes in a single link) to {in,out}. Given this generic approach to acceptance conditions, many complex aspects of argumentation can be accommodated.
Strass (2013) translates Wyner et al. (2009, 2013) into an ADF and applies it to the same problem presented in Figure 7. The approach has a version of Constraint 4, adding support along with attack and a form of negation on rules (interpreted as inapplicability). The system is proven to abide by the Rationality Constraints, though this seems to hinge on the constraint. The main issue, in our view, is that ADF requires the generation of and reasoning with (presumably correct) acceptance conditions in addition to the AF rather than on the graph per se, which was one of the main advantages of the Dungian abstraction.
Additional advantages
Our approach has three additional strengths, which we discuss briefly here, leaving for future work further comparison and contrast.
The two step
In Section 2.2, we outlined the argument construction method of ASPIC, which follows the three-step structure of Figure 1 that generates arguments from a KB: arguments are complex ‘objects’ constructed from the KB, then abstracted over in theAF; once arguments and attacks are determined, we have an AF, from which we determine extensions and consequently the justified conclusions. Yet, this can be construed to overgenerate arguments: for instance in Besnard and Hunter (2008), significant effort is devoted to analysis of relations between arguments and the specification of canonical arguments (we are not aware of similar analysis in the ASPIC framework). One might regard the arguments of ASPIC or a Logic-based approach as intermediate concepts (Wyner, 2008) or as catalysts which, having served their purpose in determining justified conclusions, are no longer essential to reasoning.
By contrast, while arguments (in their various senses) can be similarly constructed as in Section 4, this is not necessary in our framework in order to calculate the justified conclusions (our WFPEs); so far as the AF is concerned, the nodes in the graph are atomic, that is, literal or rule nodes, in specified attack relations; WFPEs are determined only with respect to such nodes and attacks. In other words, arguments such as in ASPIC or Logic-based argumentation are not essential, and there is no overgeneration of arguments as complex ‘objects’. This straightforwardly simplifies analysis as well as the calculation of justified conclusions from the three steps of Figure 1 to the two steps of Figure 8.
Two steps of argumentation.
In ASPIC or Logic-based approaches to argumentation, an argument is a rule together with the premises of the rule from which the conclusion of the rule follows. Yet it is unclear whether an argument is well-formed if no conclusion follows. This may arise in a partial KB with a rule where only some or none of the premises are asserted. In our approach, this is unproblematic. Suppose a Theory Base with only the following two rules:
Information dynamics
Related to the points in Sections 5.3.1 and 5.3.2, ASPIC or Logic-based argumentation require a recalculation of the arguments in the AF when the information in the KB dynamically changes by addition or deletion, which is followed by a recalculation of argument extensions and justified conclusions. In our framework, without such intermediate concepts, changes in the KB correlate straightforwardly to changes in the derived AF. There is, moreover, no redundancy of literal or rule nodes or of attacks among them, which may arise in ASPIC or Logic-based argumentation. While recalculation of WFPEs is required, it is clearly a simplification.
Concluding remarks and future work
We have presented a method of instantiating a Theory Base which contains strict and defeasible rules in a Dung-style abstract AF, building on and refining Wyner et al. (2009, 2013). We take a two-step approach, where the Theory Base is translated to a corresponding AF, and the conclusions of the Theory Base can be computed as extensions of that AF. This is distinct from the widespread three-step approach, where arguments are generated from the Theory Base, organised, and evaluated in an AF, yielding extensions from which justified conclusions are extracted. Our approach is a rather intuitive way of instantiating Theory Bases in AFs, directly provides justified conclusions as WFPEs, and formally expresses the variety of senses of ‘argument’, which are structures within the framework. By separating the notion of a node from the ambiguous notion of argument, we have clear criteria for what constitutes a node and attack among nodes in the framework, enabling us to explain our reasoning in terms of arguments of the appropriate granularity, for example, presenting an argument, making a case, and having a debate. In addition to accounting for benchmark problems in argumentation without a priori choices as in ASPIC or acceptability conditions as in ADF, our approach has several attractive features: arguments are not overgenerated; we can determine extensions for partial KBs; and the approach can handle information dynamics.
In future work, we will demonstrate the formal properties of our approach. In addition, we will further compare and contrast approaches to Theory Base instantiation in AFs. An important avenue of exploration and development is to add values, preferences, and weights to the KB, which then appear in the graph. In a different vein, we will explore the potential for improved explanation offered by our distinction between various senses of the term ‘argument’.
Footnotes
Acknowledgements
The authors thank the anonymous reviewers for their helpful comments. They also thank the ASPARTIX research group (Egly, Alice Gaggl, and Woltran,
) for their useful web application which has been widely used for this research. The authors appreciate the comments from reviewers and conference participants. Errors and misunderstandings rest with the authors.
Conflict of interest disclosure statement
No potential conflict of interest was reported by the authors.
Semantics for the Theory Base
In line with the spirit of the paper, we do not provide too technical or in depth a discussion; and we focus on the finite case only, which is also the most relevant given our goal to model real-world situations. Moreover, we will express the semantics of a Theory Base using an ASP program as it has a very simple syntax, although it is fully formalised.
