Attacker and Defender Counting Approach for Abstract Argumentation

06/13/2015 ∙ by Fuan Pu, et al. ∙ Tsinghua University 0

In Dung's abstract argumentation, arguments are either acceptable or unacceptable, given a chosen notion of acceptability. This gives a coarse way to compare arguments. In this paper, we propose a counting approach for a more fine-gained assessment to arguments by counting the number of their respective attackers and defenders based on argument graph and argument game. An argument is more acceptable if the proponent puts forward more number of defenders for it and the opponent puts forward less number of attackers against it. We show that our counting model has two well-behaved properties: normalization and convergence. Then, we define a counting semantics based on this model, and investigate some general properties of the semantics.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Argumentation is an important cognitive process for dealing with conflicting knowledge based on the construction and evaluation of interacting arguments [1]. It has been applied in various domains and applications such as decision making and e-participation. The most popularly used framework to talk about general issues of argumentation is that of Dung’s abstract argumentation [2], which consists of a set of arguments and a binary relation that represents the conflicting arguments. A number of argumentation semantics for abstract argumentation frameworks have been proposed that highlight different aspects of argumentation [3], such as admissible sets, preferred extension, and grounded extension. However, these semantics provide a rather rough way to evaluate arguments and may result in some undesired results [4]. A common case is that a semantics may give an empty answer. Conversely, several answers may be provided, with nothing to distinguish between them.

In order to overcome these difficulties, there is a trend towards considering and exploring the possibility of discriminating between arguments by employing a larger number of categories or continuous numerical scales [5, 6, 7, 8, 9]. One of the main advantages of these works is that it allows for a more fine-grained assessment on arguments than is provided by the traditional extensions-based approaches. We aim at following these works by evaluating the strength of arguments on a scale of numerical values from to so as to finely compare and rank arguments from the most acceptable to the weakest one(s). This fits well with recent interest in quantitative measures for the ranking analysis of argumentation [10, 11].

In this paper, our fundamental idea used to formalise argument strength is essentially the same as those found in abstract argumentation theory: argument is more acceptable than argument iff has a better defence (for it) and a lower attack (against it). In order to assess the strength of arguments in an argumentation framework, we will consider their evaluation procedures as dialogue games [12], where two fictitious agents—one PRO (the proponent) and the other OPP (the opponent)—take part in. A dialogue game begin with PRO putting forward an initial argument, and then PRO and OPP take turns in a sequence of moves called a dispute, in which each agent makes an argument that attacks its counterpart’s last move. In general, the counterpart can try a different line of attack and create a new dispute. This leads to a dispute tree structure that represents the dialogue game. Nodes in a dispute tree are labelled by arguments and are assigned the status of defender node and attacker node

of the root argument, depending upon the argument at that node is made by the proponent or by the opponent, or depending upon whether the walk length between the current node and the root node is even or odd. We claim that an argument is more acceptable if

PRO puts forward more number of defender nodes for it and OPP puts forward less number of attacker nodes against it. We will thus introduce a graded approach to assess the strength of each argument based on its dispute tree by counting its defender nodes and attacker nodes.

The rest of this paper is organized as follows. In Section 2 we briefly recall some background on Dung’s abstract argumentation and argument game. We present the attacker and defender counting semantics in Section 3. Some properties of the semantics are investigated in Section 4. Section 5 discusses related work and concludes.

2 Preliminaries

2.1 Abstract argumentation framework

We consider the basic concepts and insights of Dung’s abstract argumentation framework, in which both arguments and attacks are assumed to be abstract entities [2].

Definition 1 (Argumentation framework)

An argumentation framework (or AF, in short) is a pair where is a set of arguments and is a binary relation called attack relation. For two arguments , or means that attacks .

We denote by (respectively, ) the subset of containing those arguments that attack (respectively, are attacked by) the argument , extending this notation in the natural way to sets of arguments, so that for , and .

To define the solutions of an AF, we mean selecting a set of arguments that satisfy some acceptable criteria. Dung presents several of these properties, called extensions or semantics, which produce zero, one, or several sets of accepted arguments. These semantics are based on two important concepts: conflict-freeness and defence.

Definition 2 (Conflict-free, Defense)

Let be an argumentation framework, let and .

  • is conflict-free iff such that .

  • defends argument iff if then such that . It is also said that argument is acceptable with respect to .

Using the notions of conflict-freeness and defence, we can define a number of argumentation semantics, each embodying a particular rationality criterion.

Definition 3 (Acceptability semantics)

Let be conflict-free, and let be a function such that .

  • is admissible iff .

  • is a preferred extension iff it is a maximal (w.r.t ) admissible set.

  • is a stable extension iff it attacks all arguments in .

  • is a complete extension iff .

  • is a grounded extension iff it is the minimal (w.r.t ) complete extension.

Example 1

Consider an , described in Figure (a)a, in which and . For this example, AF has three admissible sets: , and . is the only preferred extension of AF, and it is also complete and grounded. AF has no stable extension.

2.2 Argument graph and argument game

An argumentation framework can be represented as a digraph, called argument graph, in which vertices are arguments and directed arcs characterise attack relations between arguments.

Definition 4

Let be the argument graph associated to the argumentation framework :

  • A walk from to is a sequence of arguments such that , and for all . The length of this walk, denoted by , is the number of edges used in the walk. We denote the set of all walks from to of length by .

  • A cycle is a walk . A cycle is an elementary cycle iff for any such that if then .

  • is acyclic iff there are no cycles in .

In this paper, we assess the strengths of arguments based on abstract argument games without regard to the specific internal structure of the arguments [12]. These games typically assume the presence of two fictitious agents, PRO (for “proponent”) and OPP (for “opponent”). Each game start with PRO asserting an initial argument to be tested. OPP and PRO then take turns in moving arguments that successively attack each other’s last move. A sequence of moves in which each agent moves against its counterpart’s last move is referred to as a dispute. Generally, however, an agent can backtrack to a counterpart’s previous move and initiate a new dispute. Thus, the data structure of an argument game can be represented by an argument graph’s induced dispute tree, in which each branch from root to leaf is a dispute:

Definition 5 (Dispute tree)

Let be an argumentation framework, and let . The dispute tree induced by in AF is a tree of arguments, such that the root of is , and for any , is a child of in iff .







Figure 1: Argumentation framework and dispute tree. (a) shows an argumentation framework, (b) shows the dispute tree induced in .

Nodes in a dispute tree are labelled by arguments and are assigned the status of defender node or attacker node of the root argument, depending upon whether the walk length from the current node to the root node is even or odd, or depending upon whether the argument at that node is made by PRO or by OPP. Consider two agents arguing the argumentation framework shown in Figure (a)a, and the dispute tree induced by is shown Figure (b)b. Note that this dispute tree is infinite, since both agents are able to repeat counterarguments due to the presence of cycles in the argument graph. In this dispute tree, the blue solid nodes, put forward by PRO, are defender nodes of , whereas, the red dotted nodes, made by OPP, are attacker nodes of . Each node is also assigned a superscript, which denotes the length of the move sequence from the current node to the root node. Obviously, if a node has a even-numbered superscript then it is a defender node, otherwise it is an attacker node. Note that the root node is also a defender node of since each argument has a walk with length to itself.

In this paper, we define the argument within a defender (respectively, attacker) node is a defender (respectively, attacker) of the argument within the root node. An argument is a defender or an attacker of argument depending on the length of the walk between them. Now, let us define attacker and defender based on argument graph:

Definition 6 (Attacker and Defender)

Let be an AF, and be its argument graph. Let arguments .

  • is an attacker of if there exists a walk from to such that with . Then, is said to be a -length attacker of .

  • is an defender of if there exists a walk from to such that with . Then, we call is said to be a -length defender of .

Note that an defender can also be a attacker (e.g., an defender node and an attacker node are labelled by the same argument). In the same way, two defenders can be the same argument (e.g., two different lengths of defender nodes are labelled by the same argument) and the same thing may occur for the attackers. In [5], the authors distinguish attackers (respectively, defenders) by direct and indirect. In this paper, instead, we distinguish them by different walk and walk length. Accordingly, if there exists number of -length walks from argument to argument , i.e. , then we consider that is the number of different -length attackers or defenders of .

Example 2

Consider the argumentation graph depicted in Figure 1. It can be easily see that there are two elementary cycles and . Since and , thus is a -length and -length attacker of (corresponding to the attacker nodes and in the dispute tree). Note that is also a defender of due to the -length walk (corresponding to the defender node ). There exist two walks from to of length , i.e., (corresponding to two defender nodes ), thus is two different -length defenders of .

3 Attacker and Defender Counting Semantics

In classical abstract argumentation, arguments are either acceptable or unacceptable, given a chosen notion of acceptability. This gives a rather coarse way to compare arguments. In this paper, we intend to provide a more fine-grained evaluation of arguments based on the graph structure of the argument system. Our basic starting point is that argument is more acceptable than argument iff PRO makes more defenders for and OPP makes less attackers against .

Towards such an idea, our approach is to count the number of all attackers and defenders for each argument. The less the attackers and the more defenders an argument has, the more acceptable the argument. In this approach, the main constraint is that we must be able to identify all attackers and defenders for each argument. This is quite easy in the case of argument graphs without cycles. In this section, we will introduce first a matrix approach to record and track all attackers and defenders of different lengths for every argument regardless of whether the argument graph is acyclic or cyclic. Then, counting models are established to assess the strengths of arguments, and a counting semantics is defined. The properties of this semantics are studied in the next section.

3.1 Finding attackers and defenders

In this subsection, we will use a series of matrices to memorise the number of all walks with different lengths between any two arguments, and will present a matrix product approach to compute these matrices.

Let be an argumentation framework with . We use a matrix to memorise the number of -length walks between any pair of arguments, which is defined as

Intuitively, where

is the identity matrix. Now let us define another

matrix , called attack matrix, where entry is iff ; otherwise . Obviously, is the transpose of the adjacency matrix of the attack graph of AF. Then, it is easy to see that , and further we have the following result:

Lemma 1

for each .

This lemma is common in graph theory. We introduce it here since it provides us a way to represent and compute the number of all walks with different lengths between any two arguments. It implies that by this approach we can find all attackers or defenders of various lengths of an argument. From now on, we will use to substitute for for brevity.

Proposition 1

Let be the argument graph of and its attack matrix be .

  1. If there exists a cycle in AF, then for any positive integer it holds that . 111A matrix means that there exists some entry in is non-zero. On the contrary, means that all entries in are zeros.

  2. If is acyclic, then there exists a positive integer such that for any positive integer , and for any integer . Moreover, is the length of the longest walk in .

This proposition reveals that if the attack graph of an argumentation framework is acyclic, the attackers and defenders of each argument is finite; otherwise, an argument in a cyclic graph may have infinite attackers and defenders.

3.2 The counting models for argumentation framework

Now, we will concern on establishing the counting model for the evaluation of arguments.

3.2.1 The simple counting model

The basic idea behind the simple counting model is: for each argument , for each walk length , to count the number of -attackers or -defenders for . We positively count all defenders and negatively count all attackers. This is easy to understand since an argument is always weakened by its attackers and is “reinstated” by its defenders. Therefore, in any case, the greater the number computed, the more acceptable the argument .

Cycles in argument graphs are expensive as the attackers and defenders of an argument may be infinite. Here we firstly consider the approach to count attackers and defenders under a given maximum walk length, denoted by , which will be used in order to capture finite attackers and defenders. Let with and let be the

-dimensional column vector over

. Given the maximum walk length , we define the simple counting model as


where is the column vector consisting of all ones. Note that here encodes the consideration of positively and negatively counting since is for odd and for even . The item means counting the number of all -length attackers or defenders of each argument. As goes to , then is the evaluation on arguments.

However, there are two problems with this simple counting model. The first is that for an attack graph with cycles, when goes to , then some arguments may have infinite number of attackers and defenders, which may cause go to . Considering the attack graph in Figure (a)a, for example, there are different walks from to of length . As the representation and processing of the infinite case is difficult, the simple counting model is not conducive to comparison and practical application. For example, if the counting values of two arguments are both infinite, we can not compare them.

The second problem is that the simple counting model does not distinguish different lengths of attackers and defenders. Different lengths of attackers or defenders of an argument may have different effects on the argument. The simple model just simply counting them together and does not consider which is more important and which is less important. In this paper, shorter attackers and defenders are preferred, which can effectively drive the agents to make only relevant moves, and thus we assume that a shorter attacker (respectively, defender) of an argument has more effect than a longer one on the argument [13]. More concretely, considering the move sequence in Figure (b)b, where , and are three defender nodes of , and and are two attacker nodes of . Here, we consider has more (defence) effect than on since has a longer walk to . Similar viewpoint gives that has more (defence) effect than on , and that has more (attack) effect than on .

3.2.2 The improved counting model

To remedy these two problems, we firstly define a normalization factor, which can ensure that the argument strength scale is bounded, and secondly we define a damping factor on walk length, which allows a more refined treatment on different length of attacker and defenders. Then, we write the improved counting model as


in which is the damping factor and is the normalized attack matrix defined as where the scalar is the normalization factor. Now, we can see that the damping factor provides a graded treatment of attackers and defenders of various lengths since the longer the walk length , the smaller the .

To ensure bounded , the underlying principle to select the normalization factor should satisfy the spectral radius of no more than [14, Chapter. 5]. In this paper, we select as the matrix infinite norm of , defined for by

since it provides two well-behaved properties as follows:

Theorem 1 (Normalization)

For any non-negative integer , the improved counting model defined in Equation 2 is such that .

For any argumentation system, the improved counting model can range the strength value of each argument into the interval , as it uses a dynamic normalization factor , in other words, the norm of an attack matrix used here represents the “size” of its corresponding argumentation framework. With this normalization property, all arguments can be easily compared. We must note that here the strength values of arguments are relative and not the real number of their attackers and defenders, hence, they do not make sense when they are not compared with each other.

Another property is called convergence, which states that as goes to , the improve counting model will converge.

Theorem 2 (Convergence)

The sequence defined by Equation 2 necessarily converges.

The proof this theorem needs to consider two cases, i.e., attack graph contains cycle(s) or not. We can prove that for both cases, the improved counting model always converges to a unique solution.

3.3 The counting semantics for AF

We now define the attacker and defender counting semantics for an argumentation framework as the limit of .

Definition 7

Let be an argumentation framework with . The attacker and defender counting semantics for such AF is, for all arguments ,

The strength value of each argument is denoted as .

To obtain this counting semantics, one basic idea is to compute until either or the approximation is considered adequate. If directly utilizing Equation 2, this may incur prohibitively expensive computational cost since for each we need to recompute all attackers and defenders for every argument. By Equation 2, however, we can easily derive the following iteration approach:


Then, the next valuation can be computed by the outputs of the previous iteration. With the initial valuation , we can approximate the unique solution by iteration. This iterative approach is done by using Algorithm 1. On line 1 we substitute for to reduce the calculation, and on line 1 the change is computed. In line 1 the iteration terminates when the change is under a given tolerance . It can be proved that the convergence speed of this iteration algorithm is linear and no more than .

Input: : damping factor; : attack matrix;
            : prescribed tolerance;
Output: : the approximate counting semantics
1 ; ;
2 ;
3 repeat
4       ;
5       ;
6       ;
8until ;
9 return ;
Algorithm 1 An Iteration Approach for Attacker and Defender Counting Semantics
Example 3

Consider again the argumentation framework in Example 1. Let and . Then, the valuation sequence of the attacker and defender counting model, calculated by Algorithm 1, is shown in Figure 2. The valuation sequence reflects how the strength value of each argument changes with various maximum walk length . After finitely many iterations, the valuation sequence gradually tends to be stable and converges to the approximative counting semantics within a tolerable range.

Figure 2: Valuation sequence of the attacker and defender counting model for Example 1.

4 Some Properties of Counting Semantics

In this section, we will give some general properties about the attacker and defender counting semantics.

4.1 Abstraction

The first fundamental property is called abstraction, which corresponds to the fact that the counting semantics only depends on the attack relation between arguments while it is thoroughly independent of any characteristic of arguments at the underlying language level [10]. Formally, this property corresponds to the fact that argumentation frameworks which are isomorphic have the “same” (modulo the isomorphism) counting semantics, as stated by the following definitions:

Definition 8 (Isomorphism)

Two argumentation frameworks and are isomorphic iff there exists a bijective function : such that for any , iff .

Theorem 3

Let and be the attacker and defender counting semantics of and respectively, under a given damping factor . For any isomorphism from to and for any , it holds that .

With this result, we have the following corollary about the argumentation framework whose argument graph is an elementary cycle:

Corollary 1

If the argument graph of an is an elementary cycle, then for any arguments , we have .

We have stated that the strength values of arguments are relative and do not make sense when they are not compared with each other. Actually, in most applications, we merely concern the ranking (ordering) over arguments induced by the counting semantics. Given the damping factor , the ranking on the set of arguments derived from the counting semantics is defined by: for any , iff . Intuitively, is total (i.e., , or ) and transitive (i.e., , if and , then ). Note that here means that argument is at least as acceptable as argument w.r.t. . Formally, we define if and only if and , which means and are equally acceptable w.r.t. . Moreover, , meaning is strictly more acceptable than w.r.t. , if and only if but not .

Corollary 2

Assume and be isomorphic w.r.t. , for a given damping factor , then we have , iff .

Actually, this corollary is equivalent to Theorem 3, and states that two isomorphic argument graphs give rise to two equivalent rankings on arguments.

4.2 Damping-independent ranking

Different damping factor may affect the results of the counting semantics, and thus may give the different ranking on arguments. More specifically, for an argumentation framework , for two different damping factors and , and for two arguments , the counting semantics may give that , i.e. , while the semantics may give the opposite result , i.e. . To investigate how different influence the ranking on arguments is a quite complex thing, and we will discuss it in our future works. In this paper, we mainly concern on the properties which always hold for any damping factor .

Proposition 2

Let . For any damping factor , the ranking induced by the counting semantics satisfies:

  1. If and , then .

  2. If , then ,

  3. If , then .

Property [P1] states that non-attacked arguments are always the most acceptable and attacked arguments always have non-maximal valuation. This property is common in many proposals [5, 6, 11]. Property [P2] shows that two arguments with the same -length attackers always have the same valuation (and thus are always equally acceptable). Property [P3] reveals that an argument , whose -length attackers pertain to the set of -length attackers of argument , is always more acceptable than . Using these properties, we can easily identify some rankings between arguments regardless of the damping factor .

Example 4

Consider again the argument graph shown in Figure (a)a where , , and . Obviously, has the highest rank; since . Then, we have the rankings: and .

One strong result generalizes Proposition 2 in two ways: first it considers arbitrary number of -length attackers and second, it considers various strengths of arguments. This involves a relation that compares sets of arguments, i.e. set comparison: Let be a ranking on set of arguments with respect to and let , iff there is an injective mapping from to such that for all , . Obviously, if , there must be and for any , there exists an argument in such that .

Theorem 4

Let be an attacker and defender counting semantics w.r.t the damping factor . For any , if , then it holds that .

This theorem tells us that argument is at least as acceptable as argument , when the -length attackers of at least as numerous and well-ranked as those of . The relation of set comparison between and is strong, denoted by , iff it satisfies two conditions: (1) ; (2) or for some such that and . Then, we have the strong version of Theorem 4:

Theorem 5

Let be a counting semantics w.r.t the damping factor . For any , if , then it holds that .

Example 5 (continues=Exp_Properties)

Now, let us compare arguments and . Intuitively, . We define the injective mapping from to as: and , where means the element in set . Based on the previous rankings: and , we have , and by Theorem 5, we have . Then, we can conclude the ranking on all arguments in Figure (a)a: , which are consistent with the results in Example 3.

5 Related Work and Conclusion

This paper mainly focuses on evaluating arguments by assigning a strength to each argument. In this regard, there exists numerous works [5, 6, 7, 8, 11], etc. However the most related works may be the gradual approach in [5] and the equational approach in [8] since both these two approaches and our counting approach can be seen as interaction-based approaches, i.e., evaluating arguments based on the graph structure of the argumentation framework. Our model can be seen as a linear model and has significant computational advantages.

In the short term, future work mainly aim to the following aspects. First, the damping factor plays an important role in our counting semantics. How the damping factor influences the results and how to decide it are two urgent problems. Second, argumentation has become social activities by Web 2.0 in our daily life 222The websites,, are a few examples.. How to extend our work to evaluate arguments in social context is another research point.


  • [1] I. Rahwan and G. R. Simari,

    Argumentation in artificial intelligence

    .    Springer, 2009.
  • [2]

    P. M. Dung, “On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games,”

    Journal of Artificial Intelligence, vol. 77, no. 2, pp. 321–357, Sep. 1995.
  • [3] P. Baroni, M. Caminada, and M. Giacomin, “An introduction to argumentation semantics,”

    The Knowledge Engineering Review

    , vol. 26, pp. 365–410, 12 2011.
  • [4] T. J. Bench-Capon and P. E. Dunne, “Argumentation in artificial intelligence,” Artificial intelligence, vol. 171, no. 10, pp. 619–641, 2007.
  • [5] C. Cayrol and M.-C. Lagasquie-Schiex, “Graduality in argumentation,” Journal Artificial Intelligence Research (JAIR), vol. 23, pp. 245–297, 2005.
  • [6] P.-A. Matt and F. Toni, “A game-theoretic measure of argument strength for abstract argumentation,” in Logics in Artificial Intelligence.    Springer, 2008, pp. 285–297.
  • [7] J. Leite and J. Martins, “Social abstract argumentation,” in Proceedings of the Twenty-Second international joint conference on Artificial Intelligence-Volume Volume Three.    AAAI Press, 2011, pp. 2287–2292.
  • [8] D. M. Gabbay, “Equational approach to argumentation networks,” Argument & Computation, vol. 3, no. 2-3, pp. 87–142, 2012.
  • [9] S. Modgil, F. Toni, F. Bex, I. Bratko, C. I. Chesñevar, W. Dvořák, M. A. Falappa, X. Fan, S. A. Gaggl, A. J. García et al., “The added value of argumentation,” in Agreement Technologies.    Springer, 2013, pp. 357–403.
  • [10] L. Amgoud and J. Ben-Naim, “Ranking-based semantics for argumentation frameworks,” in Scalable Uncertainty Management.    Springer, 2013, pp. 134–147.
  • [11] F. Pu, J. Luo, Y. Zhang, and G. Luo, “Argument ranking with categoriser function,” in Knowledge Science, Engineering and Management.    Springer, 2014, pp. 290–301.
  • [12] S. Modgil and M. Caminada, “Proof theories and algorithms for abstract argumentation frameworks,” in Argumentation in Artificial Intelligence, G. Simari and I. Rahwan, Eds.    Springer US, 2009, pp. 105–129.
  • [13] T. Rienstra, M. Thimm, and N. Oren, “Opponent models with uncertainty for strategic argumentation,” in Proceedings of the Twenty-Third international joint conference on Artificial Intelligence.    AAAI Press, 2013, pp. 332–338.
  • [14] R. A. Horn and C. R. Johnson, Matrix analysis.    Cambridge university press, 2012.