Attack Semantics for Abstract Argumentation

1 Introduction

Dung [1995] conceptualizes abstract argumentation in terms of attacks among arguments, together with the distinction among acceptable and unacceptable arguments. In this paper we raise the following question.

Research question. How to conceptualize argumentation in terms of successful and unsuccessful attacks, such that arguments are accepted if and only if there are no successful attacks on them?

For example, if "a suspect is innocent since he was on holidays" is attacked by "a witness saw him at the crime scene" and the suspect is not found guilty, then we say that the argument of the defense was accepted, because attacks on the innocence of the suspect were not successful.

We address several challenges. First, attacks are not only successful if they come from accepted arguments, since when two arguments attack each other, then it may be that neither argument is accepted, and thus that both attacks are successful. Therefore we may have that an argument is not accepted but its attacks are successful, which corresponds to the notion of undecided arguments in argument labelings [Caminada, 2006]. The following example illustrates the basic concepts and their relations.

Example 1 Consider the argumentation framework with arguments {a, b, c}, attacks a → a, a → b, b → c, c → b and extension {c}, visualized in Figure 1. Argument semantics says that a and b are rejected and c is accepted, and labeling semantics says that a is undecided, b is out and c is in. Attack semantics says that a → a, a → b, and c → b are successful, and the other attack is unsuccessful. Argument c is accepted since there are no successful attacks on it. The attacks by the in and undecided arguments are successful.

Leendert van der Torre CSC University of Luxembourg

leendert@vandertorre.com

Second, in attack semantics an argument is accepted when there are no successful attacks on it, but this is too weak to characterize admissibility semantics. Consider an argumentation framework with a single argument and an empty attack relation. There are two admissible extensions, since the single argument can be accepted or rejected in admissibility semantics. However, since there are no attacks, the distinction between these two admissible extensions cannot be represented by attack semantics. We therefore start with a general approach called argument - attack semantics, and we restrict attack semantics to complete and stronger semantics.

Third, Baroni et al. [2005] observe that "SCCrecursiveness can be assumed as a basic unifying concept in argumentation theory." Moreover, the SCC recursive scheme uses a generalization of Dung's semantics, in which the acceptability of arguments is considered with respect to what we call the qualified arguments. This raises the question how to define a recursive scheme for attack semantics, and how to define a corresponding generalization for attack semantics. Our generalization represents the unqualified arguments as arguments which are attacked from outside the argumentation framework. Moreover, we define also a constructive algorithm for SCC. We introduce an attack labeling approach for the algorithm, distinguishing among attacks which are successful because their attacking argument is accepted, and attacks which are successful although their attacking argument is not accepted. An attack is in when its attacker is in, undecided when its attacker is undecided, and out when its attacker is out. Consequently, an attack is successful when it is in or undecided, and unsuccessful when it is out.

The paper is organized as follows. Section 2 recalls Dung's argument semantics and introduces attack semantics and labeling, and Section 3 introduces the constructive SCC recursive procedure for attack semantics.

2 Semantics

Section 2.1 recalls Dung's semantics, distinguishing among accepted and rejected arguments. Our terminology differs from the usual one to contrast the standard approach with the new attack semantics explained in the following, distinguishing among successful and unsuccessful attacks. We start Section 2.2 with a combined argument - attack semantics for the general case, and Section 2.3 introduces attack semantics for complete and stronger semantics. In Section 2.4 we discuss attack labelings, which we use to define Algorithm 2 in Section 3.

2.1 Argument semantics

Dung [1995] introduces what we call here argument semantics, associating with each graph a set of so-called argument extensions, which are subsets of the nodes of the graph. Some authors therefore call it extension based semantics [Baroni and Giacomin, 2007].

Our presentation follows Baroni et al. [2005], where the acceptability of arguments is considered with respect to a designated subset of arguments, since we need this generalization to define the SCC recursive algorithm in Section 3. This set, which we call the set of qualified arguments, contains the arguments that an extension may consist of. Intuitively, it is used to filter out arguments that do not qualify for acceptance. This is necessary when we evaluate only a subset of arguments, but at the same time know that some arguments in this subset cannot be accepted due to attacks from outside the subset.

Definition 1 assumes an underlying mechanism of argument generation defining a set of arguments [Baroni and Giacomin, 2007], which is typically infinite, and which we call the universe of arguments and represent by U. An acceptance function E is a function that associates sets of acceptable arguments with a finite set of arguments A ⊆ U, a set of arguments produced by a reasoner at a given instant of time, a binary relation →⊆ A × A, representing the attack relation among these arguments, and what we call here the qualified arguments Q ⊆ A.

Definition 1 (Argument semantics) Let U be the universe of arguments. An acceptance function

is a partial function which is defined for each argumentation framework 〈A,→〉 with finite A ⊆ U and →⊆ A × A, together with qualified arguments Q ⊆ A, and which associates with argumentation framework 〈A,→〉 and qualified arguments Q sets of subsets of A: E(〈A,→〉,Q) ⊆ 2A. If a → b we say that a attacks b, a is an attacker of b, or b is attacked by a. If E ∈ E(AF,Q), then we say that E is an extension of AF and Q under the E semantics, and we say that the arguments in E are accepted and the arguments not in E are rejected.

Admissibility semantics in Definition 2 accepts only arguments that are defended by other accepted arguments, and therefore E(〈A, →〉, Q) ⊆ 2Q. Other authors have introduced semantics for which this property does not hold, e.g., Baroni et al. [2005] introduced CF1 and CF2 semantics. They observe also that Dung's semantics can be recovered by setting Q to A.

Definition 2 (Admissibility semantics) Let AF = 〈A,→〉 be an argumentation framework, and let Q ⊆ A and E ⊆ Q be sets of arguments. cf(E) if and only if there are no arguments a, b ∈ E such that a → b. E defends a if and only if ∀b ∈ A such that b → a, ∃c ∈ E such that c → b. Let D(E) = {a ∈ Q | E defends a}.

• E ∈ Eadmiss(AF,Q) if and only if cf(E) and E ⊆ D(E).
• E ∈ Ecompl(AF,Q) if and only if cf(E) and E = D(E).
• E ∈ Eground(AF,Q) if and only if E is smallest in Ecompl(AF,Q) w.r.t. set inclusion.
• E ∈ Epref(AF,Q) if and only if E is largest in Eadmiss(AF,Q) w.r.t. set inclusion.
• E ∈ Estable(AF,Q) if and only if cf(E) and ∀b ∈ A\E ∃a ∈ E : a → b.

If E ∈ Eadmiss(AF,Q) we say that E is an admissible extension of AF and Q, etc.

Example 2 Consider AF = 〈A, →〉 with A = {a, b, c, d, e} and {a → b, b → a, b → c, c → d, d → e, e → c} visualized in Figure 2. The complete extensions are Ecompl(AF,A) = {∅, {a}, {b, d}}. ∅ is the unique grounded extension, {a} and {b, d} are the preferred extensions, and {b, d} is the stable extension. In the complete extension ∅ the arguments are rejected, because they are not defended. In the extension {b, d} the other arguments are rejected, because they are attacked by an accepted counterargument.

2.2 Attack - argument semantics

We generalize the argument semantics by selecting from the graph not only a set of nodes, but also a set of edges. This represents intuitively that attacks can be successful or unsuccessful. A similar kind of intuition is formalized in extended argumentation frameworks with second or higher order attacks by [Barringer et al., 2005; Modgil and Bench-Capon, 2008; Boella et al., 2009; Baroni et al., 2011b], where attacks are treated as arguments which can be accepted and rejected too. In this paper we do not consider second or higher order attacks, though our generalization may be of use for such extended argumentation frameworks too.

Definition 3 represents argument - attack semantics by a function associating with each graph a set of its so-called argument-attack extensions, which are sets of nodes and sets of edges from the graph. An argument-attack extension can contain an edge between arguments a and b, without containing the arguments a and b themselves. In other words, the argument attack extensions do not have to be subgraphs.

Since we aim to rephrase all concepts in terms of attack, the qualified arguments are implicitly represented as arguments not attacked from outside the argumentation framework: Q = {a ∈ A |̸ ∃b ∈ U \ A : b → a}. We therefore extend → to range over U × A, and we do not add Q as a third parameter to the acceptance function F.

Definition 3 (Argument - attack semantics) An accep-

tance function F : 2U × 2U×U → 22U ∪2U×U is a partial function which is defined for each argumentation framework 〈A, →〉 with finite A ⊆ U and →⊆ U × A, which associates with argumentation framework 〈A,→〉 sets of subsets of A and →: F(〈A,→〉) ⊆ 2A∪→. For each attack a → b, we say that a is the attacking argument, and b is the attacked argument. Moreover, for an argument a, we say that all its attacks are the attacks a → b, and we say that all the attacks on a are all attacks b → a.

We can enforce additional constraints on argument attack semantics, just as additional constraints are sometimes enforced on argument semantics. The qualified constraint says that the accepted arguments depend only on whether an argument is attacked by an argument outside of A, not on the identity of the attackers outside the argumentation framework. The attacker dependence constraint says that if one attack by an argument is successful, then all attacks by this argument are successful. The successful attack constraint says that attacks by accepted argument are successful (but not necessarily vice versa). The unsuccessful attack constraint says that the attacks by arguments which are attacked by an accepted argument, are not successful. The defended attack constraint says that if there is no accepted argument attacking the attacker of an attack, then the attack is successful. The success of an attack in terms of the acceptance of arguments constraint says that an attack b → c is unsuccessful if and only if there is an accepted argument a attacking b. Therefore, an attack b → c is successful if and only if either its attacking argument b is accepted, or for all arguments a attacking argument b, argument a is rejected.

Definition 4 (Constraints)

Qualified For all 〈A,→1〉 and 〈A,→2〉, if same attacks in A: →1 ∩(A×A) =→2 ∩(A×A) and same attacked from outside: {a ∈ A | ∃b ∈ U \ A : b →1 a} = {a ∈ A | ∃b ∈ U \ A : b →2 a}, then same accepted arguments F(〈A, →1〉) ∩ A = F(〈A, →2〉) ∩ A.

Attacker dependence ∀E∪↪→∈ F(〈A,→〉): If a → b and a → c, then either both attacks are successful, or none of them.

Successful attack ∀E∪↪→ ∈ F(〈A,→〉): if both a ∈ E and a → b, then a ↪→ b;

Unsuccessful attack ∀E∪↪→∈ F(〈A,→〉): if a ∈ E, a → b and b → c, then we do not have b ↪→ c, i.e. b ̸↪→ c;

̸

Defended attack ∀E∪↪→∈ F(〈A,→〉): if b → c and ∃a ∈ E : a → b, then b ↪→ c;

̸

Success in terms of acceptance ∀E∪↪→∈ F(〈A,→〉):

b ↪→ c if and only if b → c and ̸ ∃a ∈ E : a → b.

Proposition 1 Success in terms of acceptance implies attacker dependence, successful attack, unsuccessful attack, and the defended attack constraint.

In the following, we consider argument attack semantics together with the constraint that defines success in terms of acceptance. However, this does not necessarily imply that also acceptance can be defined in terms of success. For example, consider again the argumentation framework with a single argument and an empty attack relation. There may be two extensions under the success in terms of acceptance constraint, since the single argument can be accepted or rejected. However, since there are no attacks, the acceptance of this argument cannot be represented by the success of attacks.

The following definition uses the constraint to relate argument semantics to argument attack semantics.

Definition 5 (Relation) The argument semantics E and argument attacks semantics F are equivalent, written as E = F, if E∪↪→ ∈ F(〈A,→〉) if and only if

• E ∈ E(〈A,→∩A×A〉,Q), for qualified arguments Q = {a ∈ A |̸ ∃b ∈ U \ A : b → a}, and
• b ↪→ c ⇔ b → c∧ ̸ ∃a ∈ E : a → b.

We write Fadmiss for the acceptance function equivalent to Eadmiss, etc.

The following example illustrates grounded, preferred and stable semantics using argument attack semantics.

Example 3 (Continued fromExample 2) The grounded extension ∅ has only successful attacks, the preferred extension {a} has {a ↪→ b, c ↪→ d, d ↪→ e, e ↪→ c} as successful attacks, and the stable extension {b, d} has {b ↪→ a, b ↪→ c, d ↪→ e} .

Proposition 2 If the universe of arguments U is infinite, then for every E, there is an F equivalent to it.

Proof. By construction. Assume U is infinite, and consider 〈A,→1〉 and Q. Since U is infinite and A is finite, there exists an argument a in U\A. Let →2=→1 ∪{a →2 b | b ∈ A\Q}.

Proposition 3 If the universe of arguments U is infinite, then for every F with success in terms of acceptance, and the qualified constraint, there is precisely one E equivalent to it.

Proof (sketch). The construction in Proposition 2 maps each element in E to an F satisfying the two constraints.

Proposition 4 characterizes defense and reinstatement as the failure of attacks from arguments which are attacked by accepted arguments: if an argument a is accepted, then for all arguments b attacked by a, the attacks of b are unsuccessful.

Proposition 4 (Defense) If E∪↪→∈ E(〈A,→〉), then for all arguments a, b, c we cannot have a ∈ E, a → b and b ↪→ c.

Proof. Assume a ∈ E and a → b. Since E is conflict free, ∃a′ ∈ E : a′ → a, and consequently a ↪→ b due to the successful in terms of acceptance constraint. Therefore we cannot have b ↪→ c due to the same constraint.

Proposition 5 shows that attacks from outside the argumentation framework are always successful.

Proposition 5 (Context) If E∪↪→∈ E(〈A,→〉), then for all arguments a and b we have that a → b and a ̸∈ A implies a ↪→ b.

Proof (sketch). Follows from the fact that there are no attacks on arguments outside A, together with the success in terms of acceptance constraint.

The following theorems are proven directly from the definitions presented thus far, but could also have been proven via the alternative characterization using labeling semantics discussed in Section 2.4. An extension is admissible if and only if for all accepted arguments, none of the attacks on it are successful.

Theorem 1 (Admissible) E∪↪→∈ Fadmiss(AF) if and only if cf(E) and ∀a ∈ E ̸ ∃b ∈ U : b ↪→ a.

Proof. ⇒: follows directly from the success in terms of acceptance constraint. ⇐: We prove the contrapositive. Assume the extension E∪↪→ is not admissible, then there is an accepted argument a ∈ E which is not defended against an attack from argument b: b → a and ̸ ∃c ∈ E : c → b. From the definition of successful attack, this implies that the attack of b on a is successful: b ↪→ a.

A complete extension is an admissible extension, in which an argument is accepted if and only if none of the attacks on it are successful.

Theorem 2 (Complete) E∪↪→∈ Fcompl(AF) if and only if cf(E) and a ∈ E ⇎ ∃b ∈ U : b ↪→ a.

Proof. By Definition 2, E is a set of arguments c such that for all arguments b attacking c there is an argument a ∈ E attacking b. ⇔E is a set of arguments c such that there is no argument b attacking c for which there is no argument a ∈ E attacking b. ⇔E is the set of arguments for which there is no argument b successfully attacking it. The latter step follows directly from success in terms of acceptance.

Theorem 3 characterizes complete semantics in terms of the success of attacks, which is the basis for the attack semantics in Section 2.3. In complete semantics, an attack c → d is successful if and only if for each successful attack b → c, there is a successful attack a → b.

Theorem 3 (Complete: Success propagation)

E∪↪→∈ Fcompl(AF) if and only if for each c → d we have c ↪→ d if and only if for each b ↪→ c we have an a ↪→ b.

Proof (sketch). Follows from Theorem 2 together with the success in terms of acceptance.

A grounded extension is a complete extension with a maximal set of successful attacks.

Theorem 4 (Grounded) E∪↪→∈ Fground(AF) if and only if E∪↪→∈ Fcompl(AF) and there is no E′∪↪→′∈ Fcompl(AF) with ↪→⊂↪→′ .

Proof (sketch). Follows from Proposition 2,3 and Theorem 2.

A preferred extension is an admissible extension with a minimal set of successful attacks.

Theorem 5 (Preferred) E∪↪→∈ Fpref(AF) if and only if E∪↪→∈ Fadmiss(AF) and there is no E′∪↪→′∈ Fadmiss(AF) with ↪→′⊂↪→.

Proof (sketch). Follows from Proposition 2,3 and Theorem 2. A stable extension has no successive attacks.

Theorem 6 (Stable) E∪↪→ ∈ Fstable(AF) if and only if cf(E) and there are no arguments a, b, c with a ↪→ b and b ↪→ c.

Proof (sketch). Follows from Proposition 2,3 and Theorem 2.

2.3 Attack semantics

From now on, in this paper we consider only complete semantics or one of its refinements, such as grounded, preferred or stable semantics. We introduce the following attack semantics, a function that associates with each graph a set of its attack extensions, which are sets of edges from the graph.

Definition 6 (Attack semantics) An acceptance function A : 2U ×2U×U → 22U×U is a partial function which is defined for each argumentation framework 〈A,→〉 with finite A ⊆ U and →⊆ U × A, which associates with argumentation framework 〈A,→〉 sets of subsets of →: A(〈A,→〉) ⊆ 2→. If a → b and b → c we say that a → b is a predecessor of b → c, and that b → c is a successor of a → b.

Theorem 3-6 can be rephrased in terms of attack semantics, because for complete semantics (and stronger) an argument is accepted when there are no successful attacks on it (Theorem 2).

Corollary 1 (Complete Attack Semantics)

↪→∈ Acompl(AF) if and only if for each c → d we have c ↪→ d if and only if for each b ↪→ c we have an a ↪→ b.

↪→∈ Aground(AF) if and only if ↪→∈ Acompl(AF) and there is no ↪→′∈ Acompl(AF) with ↪→⊂↪→′ .

↪→∈ Apref(AF) if and only if ↪→∈ Acompl(AF) and there is no ↪→′∈ Acompl(AF) with ↪→′⊂↪→.

↪→∈ Astable(AF) if and only if ↪→∈ Acompl(AF) and there are no arguments a, b, c with a ↪→ b and b ↪→ c.

Example 4 Consider the argumentation framework AF = 〈A,→〉 with arguments A = {a, b, c, d, e, f} and attacks {a → b, b → a, b → c, c → d, d → e, e → f}, visualized in Figure 3. Assume that we know that a and b are rejected. Then the attacks a → b and b → a are successful, and consequently we can derive by attack propagation that all attacks are successful.

2.4 Labeling semantics

In this section we show how to use labelings [Jakobovits and Vermeir, 1999; Caminada, 2006] to make the relation between argument and attack semantics more precise, which is useful for Algorithm 2 in Section 3. We consider the set of labelings of an argumentation framework satisfying the following conditions: an argument is in if and only if all its attackers are out, an argument is out if and only if there is an attacker that is in, and an argument is undecided if and only if none of its attackers is in, and at least one of its attackers is undecided.

We now introduce an attack labeling semantics. Whereas argument labelings partition rejected arguments into out and undecided arguments, attack labelings partition successful attacks into in and undecided attacks. Intuitively, an undecided attack is like a threat: it is not based on an accepted attacking argument, but it can still be used to reject the attacked argument.

Definition 7 (Attack labeling semantics) Let U be the universe of arguments, and let L be the set of functions from relations over arguments →⊆ U × U to {in, out, und}. An acceptance function E : 2U × 2U×U → 2L(U×U) is a partial function which is defined for each argumentation framework 〈A,→〉 with finite A ⊆ U and →⊆ U × A, which associates with argumentation framework 〈A,→〉 sets of labelings of →: E(〈A,→〉) ⊆ L(→).

We define attack labeling analogous to argument labeling. An attack is in when its attacking argument is in, an attack is undecided when its attacking argument is undecided, and an argument is out when its attacking argument is out. An attack is successful when it is in or undecided, whereas an argument is accepted when it is in. For example, if an argument is rejected, but at least one of its attacks is successful, then the argument is undecided.

Example 5 (Continued fromExample 3) The grounded extension ∅ has only undecided attacks, the preferred extension {a} has in attack a ↪→ b and undecided attacks c ↪→ d, d ↪→ e, e ↪→ c, and the stable extension {b, d} has in attacks b ↪→ a, b ↪→ c, d ↪→ e and no undecided attacks.

We now rephrase the argument labeling conditions in terms of attack labeling. For complete semantics, each labeling corresponds to a complete extension, where the in arguments of the labeling are the accepted arguments of the extension. Analogously, an attack is in if and only if all its predecessors are out, an attack is out if and only if there is a predecessor that is in, and an attack is undecided if and only if none of its predecessors is in, and at least one of its predecessors is undecided.

Theorem 7 Complete semantics is characterized by the following two conditions.

1. For all b and c we have L(b → c) =out, if and only if there is an a such that we have L(a → b) =in.
2. For all b and c we have L(b → c) =in, if and only if for all a we have L(a → b) =out.

3 SCC recursive algorithm

3.1 SCC-recursive argumentation semantics

In this subsection, we describe [Baroni et al., 2005]'s SCCrecursive scheme which is based on the graph theoretical notion of strongly connected component, i.e., SCCs provide a unique partition of a directed graph into disjoint parts where all nodes are mutually reachable. The authors observe that "the underlying basic ideas can be summarized as follows: (1) the argumentation framework is partitioned into its strongly connected components; they form a partial order which encodes the dependencies existing among them according to the directionality principle; (2) the possible choices for extensions within each initial strongly connected component are determined using a semantic-specific base function which returns the extensions of argumentation frameworks consisting of a single strongly connected component; (3) for each possible choice determined at step 2, according to the reinstatement principle, the nodes directly attacked within subsequent strongly connected components are suppressed and the distinction between defended and undefended nodes is (possibly) taken into account; (4) the steps 1-3 above are applied recursively on the restricted argumentation frameworks obtained at step 3."

Most presentations of the SCC recursive scheme (e.g., [Baroni and Giacomin, 2009; Baroni et al., 2011a]) present only the following definition, and they observe that it is well founded. They also observe that it is quite complicated and its detailed illustration is beyond the scope of the paper; we also do not attempt to present it here in further detail, but refer the reader to [Baroni et al., 2005].

Definition 8 ( [Baroni et al., 2005], Definition 20) A given argumentation semantics is SCC - recursive if and only if for any argumentation framework AF = 〈A, →〉, ES(AF ) = GF(AF,A), where for any AF = 〈A,→〉 and for any set C ⊆ A, the function GF(AF, C) ⊆ 2A is defined as follows: for any E ⊆ A, E ∈ GF (AF, C) if and only if

• in case |SCCSAF | = 1, E ∈ BFS(AF,C),
• otherwise, ∀S ∈ SCCSAF we have (E ∩ S) ∈ GF (AF ↓UPAF (S,E), UAF (S, E) ∩ C),

where

• SCCSAF denotes the set of strongly connected components of AF (a maximal set such that in the transitive closure of →, each argument of an SCC attacks all other ones),
• BFS(AF,C) is a function, called base function, that, given an argumentation framework AF = 〈A,→〉 s.t. |SCCSAF | = 1 and a set C ⊆ A, gives a subset of 2A,
• UPAF (S,E) = {a ∈ S |̸ ∃b ∈ E : b ̸∈ S, b → a}, all arguments that are not attacked by an accepted argument outside of S,
• UAF (S,E) = {a ∈ UPAF (S,E) | ∀b ̸∈ E : b ̸∈ S, b → a ⇒ ∃c ∈ E : c ̸∈ S, c → b}, all arguments that are defended against attacks from outside of S, and
• AF ↓ S = 〈S,→ ∩E ×E)〉, the restriction of AF to S.

Baroni et al. [2005] show also that the base function for admissible, grounded, preferred and stable semantics are the ones given in Definition 2, and therefore that all these semantics are SCC recursive.

Example 6 (Continued fromExample 2) Consider again the example visualized in Figure 2. There are two SCC {a, b} and {c, d, e}. The SCC {a, b} is not attacked by anything, {a} and {b} are the complete extensions of this SCC. Considering {a}, the SCC we get is {c, d, e}. Considering, instead, {b, d}, since b is in, the SCC {c, d, e} goes into recursion and becomes {d, e}, which consists of two SCCs, {d} and {e}.

3.2 Iterative procedure

Baroni et al. [2005] observe that Definition 8 has also a straightforward constructive interpretation, but they do not give a procedure. We believe that Algorithm 1 is easier to understand than Definition 8. The X label stands for unlabeled arguments in a partial labeling. Line 2 starts a loop where partial labelings are extended by first in lines 4-7 applying the socalled characteristic function, and then in lines 11-19 applying the base function BF . The characteristic function in lines 4-7 assigns the in label to the arguments attacked only by out arguments, and out to arguments attacked by at least one in argument, following [Caminada, 2006]. Lines 8-10 assign the label und to those arguments which are attacked by out and und arguments only (and therefore at least by one und argument, otherwise it would already have been labeled in); these lines are not strictly necessary, but speed up the algorithm. In line 11, SCC(〈A,→〉, L) returns the sets of X-labeled arguments of A that (1) are maximal strongly connected components and (2) are not attacked by any X-labeled arguments. If such a set exists, then BF(〈A,→〉, C) applies the base function to 〈A,→〉 where C corresponds to arguments which are defended against attacks from outside of 〈A,→〉.

Theorem 8 (Soundness and completeness) The iterative procedure is sound and complete with respect to the SCC recursive scheme, in the sense that it returns all labelings that can be reconstructed using the base function.

3.3 SCC for attack semantics

For argument semantics, the SCC scheme partitions a SCC into defended and undefended arguments. For attack semantics, instead, an SCC consists in a set of attacks, together with attacks from outside the SCC. Algorithm 2 is the counterpart of Algorithm 1 for attack semantics by using the relations shown in Section 2. Line 2 starts a loop where partial labelings are extended by first in lines 4-10 applying the characteristic function, and then in lines 14-21 applying the base function for attack semantics BFAtt. The characteristic function in lines 4-10 assigns the label in to the attacks whose predecessors are labeled out, and attacks with a predecessor which is labeled out are labeled in. In lines 11-13, the attacks whose predecessors are not X-labeled get the label und; also for attack semantics these lines are not strictly necessary, but speed up the algorithm. Finally, similarly to Algorithm 1, SCCAtt(AF,L) returns the sets of X-labeled attacks that (1) form a SCC together with those attacks on it labeled und, and that (2) do not have an X-labeled predecessor, and BFAtt(〈A,→〉, C) is the base function for attack semantics, as given in Corollary 1 for various kinds of semantics. We illustrate how algorithm SCCAtt works by means of Example 7.

Example 7 (Continued) Consider again the argumentation framework visualized in Figure 2. We start with the following situation, where L and L are the partial labeling and the set of starting partial labelings for the SCCAtt algorithm, respectively:

• L = {L};

• SCCAtt(.) = {{a → b, b → a}};
• BFAtt(.) = {{a → b, b → a}, {a → b}, {b → a}};

We obtain the following partial labelings:

• L = {L1,L2,L3};

Now, we select the first partial labeling, L1, in order to compute a complete labeling:

• L = {L1,L2,L3};

• SCCAtt(.) = {{c → d, d → e, e → c}};
• BFAtt(.) = {{c → d, d → e, e → c}};

L1 is the first attack labeling we get. Then, we consider the other two partial labelings. We start with L2.

• SCCAtt(.) = {{c → d, d → e, e → c}};
• BFAtt(.) = {{c → d, d → e, e → c}};
• a → b b → a b → c c → d d → e e → c; L2 in out out und und und

Then we consider the last partial labeling, L3.

Theorem 9 follows for complete semantics, when we have a one to one correspondence between argument labelings and attack labelings.

Theorem 9 (Soundness and completeness) For complete semantics and its refinements, Algorithm 2 returns the set of all attack labelings.

3.4 Implementation

The two algorithms above have been implemented, and we are collecting and evaluating preliminary results. The source code and additional information can be found at:

The prototype has been developed using Python programming language v2.6., an interpreted, general-purpose highlevel programming language, whose reference implementation (CPython) is an open source software. In particular, we developed the Python prototype, using the python.graph package 1 and exploiting its inner built-in features (e.g., search and traversal algorithms, cycle detection). In our implementation, the argumentation framework is a directed graph and the available SCCs are associated to the arguments attacking them, using dictionaries and lists.

The argumentation framework is characterized by the following structures:

1. a directed graph called digraph;
2. a list of strongly connected components. This is represented by means of a list of lists, each of them containing the nodes of the SCC itself;
3. a dictionary implementing the base function. The SCCs are the keys of the dictionary, and the arguments attacking each SCC are its values.

We use two algorithms classes provided by python.graph, concerning searching (e.g., depth first searching used for breadth-first search) and accessibility. The base function BF is computed starting from the attackers of a SCC from outside the SCC itself. After the graph is built and the BF is computed, the labeling can start by iterating on each label to be set. First of all, all arguments are labelled X. Then, each argument is labelled IN or OUT according to:

• being part of an attacked SCC;
• attacking a SCC;
• attacking/being attacked by a labelled argument;

At the end, remaining unlabeled arguments are labelled as UND, and the final set of labels is returned.

The algorithm always converges in a few steps, depending on the number of the attacked SCCs and on the number of attack relations. Preliminary results show also that maintaining a cache for intermediate labelings leads to a benefit in terms of number of operations (around 10% less operations of graph access).

Future work will be described on the website. For example, we are now exploring how to modify the algorithms for creating, accessing and manipulating graphs (e.g., by adopting NetworkX, a Python package for the creation, and manipulation of complex networks), in order to avoid cross checks in graph cycles management.

1 http://code.google.com/p/python-graph/

4 Concluding remarks

To represent and reason with argumentation there is a choice between Dung's two valued argument evaluations [Dung, 1995] and three value labelings [Caminada, 2006]. Some people find it easier to work with the former, because it is the simplest model, and some other people find it easier to work with the latter, because the value of a label depends on the value of its attackers only. We find it more natural to conceptualize argumentation and dialogue in terms of successful and unsuccessful attacks, and we suspect that some other people might find it useful to use combinations of these approaches.

In this paper we therefore introduce attack semantics, that conceptualizes argumentation in terms of successful and unsuccessful attacks, such that arguments are accepted if and only if there are no successful attacks on them. We introduce also attack labeling semantics and general argument attack semantics. We compare these semantic approaches in detail with Dung's traditional extension based semantics, which we call argument semantics to contrast it with our attack semantics, and Jakobovits-Vermeir-Caminada labeling semantics. Since we focus on attack semantics coinciding with traditional semantics, there exist meaningful instantiations of our abstract theory. We discuss also limitations of attack semantics, in particular it cannot be used for admissible semantics (here, argument attack semantics or argument attack labelings must be used).

Moreover, in this paper we introduce a constructive SCC recursive procedure for attack semantics. In our opinion, SCC techniques are not useful only for computational reasons, but in particular also for conceptual reasons. For instance, as discussed extensively by Baroni et. al [2005], SCC techniques can be used to implement directionality. We believe this may be useful, when argumentation theory is further generalized to partial acceptance and partial success.

Extended argumentation frameworks with second or higher order attacks by [Barringer et al., 2005; Modgil and BenchCapon, 2008; Boella et al., 2009; Baroni et al., 2011b] treat attacks as arguments which can be accepted and rejected too. Assume, for instance, the AFRA based argument α representing the attack a → b. The acceptance of α corresponds to the success of the attack a → b. Moreover, in metaargumentation [Boella et al., 2009] the attack a → b is flattened into four arguments accept(a), Xab, Yab and accept(b) with accept(a) → Xab, Xab → Yab, and Yab → accept(b). If there are no other arguments attacking the auxiliary arguments Xab and Yab, then we have that the label of the attack argument Yab is identical to the label of accept(a).

Concerning further research, one may consider a common framework for iterated belief revision and abstract argumentation, such that the revision of b by a corresponds to attacks of a on b. In particular, one could define generalizations of belief revision with revision cycles. In iterated belief revision there are no revision cycles, but in argumentation theory there can be attack cycles among the arguments. Therefore the challenge is to introduce cycles in iterated belief revision too, and give them an intuitive explanation. Moreover, another challenge consists in introducing partial acceptance and success in abstract argumentation.

Acknowledgements

The first author acknowledges support of the DataLift Project ANR-10-CORD-09 founded by the French National Research Agency.