ConArg: A Constraint-based Computational ... - Semantic Scholar

ConArg: A Constraint-based Computational Framework for Argumentation Systems Stefano Bistarelli and Francesco Santini Dipartimento di Matematica e Informatica, Universit`a di Perugia Via Vanvitelli 1, 06123 Perugia, Italy Email: [bista,francesco.santini]@dmi.unipg.it

Abstract—We propose ConArg, a tool based on Constraint Programming, to model and solve various problems related to the Argumentation research field. Constraint Satisfaction Problems (CSPs) offer a wide number of efficient techniques (as inference and search algorithms) that can tackle the complexity in finding all the possible Dung’s conflict-free, admissible, complete, stable, preferred and grounded extensions in Argumentation Frameworks. Moreover, we can use the tool to solve some computationally hard problems presented in [1]. To implement ConArg, we have used JaCoP, a Java library which provides the user with a Finite Domain Constraint Programming paradigm, to model and solve these two problems. ConArg is able to randomly generate two different kinds of smallworld networks in order to find Dung’s extensions on such interaction graphs. We present the main features of ConArg and the reported performance in time. Keywords-Argumentation Frameworks; Constraint Satisfaction Problems;

I. I NTRODUCTION Interactions are a core part of all multi-party systems (e.g. multi-agent systems). Argumentation [2] is based on the exchange and the evaluation of interacting arguments which may represent information of various kinds, especially beliefs or goals. Argumentation can be used for modeling some aspects of reasoning, decision making, and dialogue. For instance, when an agent has conflicting beliefs (viewed as arguments), a (nontrivial) set of plausible consequences can be derived through argumentation from the most acceptable arguments for the agent. Argumentation has become an important subject of research in Artificial Intelligence and it is also of interest in several disciplines, such as Logic, Philosophy and Communication Theory [3]. Many theoretical and practical developments build on Dung’s seminal theory of argumentation. A Dung Argumentation Framework (AF) is a directed graph consisting of a set of arguments and a binary conflict based attack relation among them. The sets of arguments to be considered are then defined under different semantics, where the choice of semantics equates with varying degrees of scepticism or credulousness. The main issue for any theory of argumentation is the selection of acceptable sets of arguments, based on the way arguments interact. Intuitively, an acceptable set of arguments must be in some sense coherent and

strong enough (e.g. able to defend itself against all attacking arguments). Constraint Programming (CP) is a powerful paradigm for solving combinatorial search problems that draws on a wide range of techniques from artificial intelligence, computer science, databases, programming languages, and operations research. Constraint programming is currently applied with success to many domains, such as scheduling, planning, vehicle routing, configuration, networks, and bioinformatics [4]. Constraint solvers search the solution space either systematically, as with backtracking or branch and bound algorithms, or use forms of local search which may be incomplete. Systematic method often interleave search and inference, where inference consists of propagating the information contained in one constraint to the neighboring constraints [4]. In this paper we propose ConArg [5], a Java-based tool that can find the classical extensions proposed by Dung [2], i.e. conflict-free, admissible, complete, stable, preferred and grounded, and the solution of some hard problems related to Argumentation presented in [1]. To model these argumentation problems with constraints we adopt Java Constraint Programming solver [6] (JaCoP), a Java library which provides the Java user with Finite Domain Constraint Programming paradigm [4]. An example of the hard problems presented in [1], which ConArg is able to solve, is, given a weighted argument system, a set of arguments and inconsistency budget β, checking whether β is minimal. This specific problem is coNP-complete [1]. Also finding all the classical Dung’s extensions is not “easy”: the number of these extensions, which in practice are subsets of the Args set of arguments, may explode for large Args (the powerset of Args has 2|Args | elements). Therefore, it is important to use techniques to tackle this inherent complexity, as those ones adopted in CP. This is particularly important with conflict-free extensions, which represents the least constrained extension among classical ones in [2]. With ConArg, the user can generate two different kinds of small-world networks: Barabasi and Kleinberg graphs, as shown in [7]. We suppose that interaction graphs, where nodes are arguments and edges are attacks (see Sec. II),

represent in this case a kind of social network and consequently show the related small-world properties [8], [9]. A practical example can be the study of discussion fora, where the users post their arguments that can attack other users’ arguments [8], [10]. This work follows and extends with an implemented tool the research line firstly proposed in [11], [12] from the theoretical point of view. The remainder of this paper is organized as follows. In Sec. II we report the theory behind Dung Argumentation (and weighted AFs [1]), while in Sec. III we summarize the background on (weighted) constraints. In Sec. IV we show the mapping from AFs to CSPs, which is at the hearth of ConArg. In Sec. V we describe the main features of ConArg, while in Sec. VI we show the tests that prove the feasibility of a constraint-based framework to solve AFs. A comparison with related work is given in Sec. VII. Finally, Sec. VIII presents our conclusions. II. D UNG A RGUMENTATION In [2], the author has proposed an abstract framework for argumentation in which he focuses on the definition of the status of arguments. For that purpose, it can be assumed that a set of arguments is given, as well as the different conflicts among them. An argument is an abstract entity whose role is solely determined by its relations to other arguments. Definition 1: An Argumentation Framework (AF) is a pair hArgs , Ri of a set Args of arguments and a binary relation R on Args called the attack relation. ∀ai , aj ∈ Args , ai R aj means that ai attacks aj . An AF may be represented by a directed graph (the interaction graph) whose nodes are arguments and edges represent the attack relation. A set of arguments B attacks an argument a if a is attacked by an argument of B. A set of arguments B attacks a set of arguments C if there is an argument b ∈ B which attacks an argument c ∈ C. The “acceptability” of an argument [2] depends on its membership to some sets, called extensions. These extensions characterize collective “acceptability”.

b c

d

a Figure 1. An example of Dung Argumentation Framework; e.g. c attacks d.

In Fig. 1 we show an example of AF represented as an interaction graph: the nodes represent the arguments and the directed arrow from c to d represents the attack of c towards d, that is c R d. Dung [2] gave several semantics to “acceptability”. These various semantics produce none, one or several acceptable sets of arguments, called extensions.

In Def. 2 we define the concepts of conflict-free and stable extensions: Definition 2: A set B ⊆ Args is conflict-free iff no two arguments a and b in B exist such that a attacks b. A conflictfree set B ⊆ Args is a stable extension iff for each argument which is not in B, there exists an argument in B that attacks it. The other semantics for “acceptability” rely upon the concept of defense: Definition 3: An argument b is defended by a set B ⊆ Args (or B defends b) iff for any argument a ∈ Args , if a attacks b then B attacks a. An admissible set of arguments according to Dung must be a conflict-free set which defends all its elements. Formally: Definition 4: A conflict-free set B ⊆ Args is admissible iff each argument in B is defended by B. Besides the stable semantics, three semantics refining admissibility have been introduced by Dung [2]: Definition 5: A preferred extension is a maximal (w.r.t. set inclusion) admissible subset of Args . An admissible B ⊆ Args is a complete extension iff each argument which is defended by B is in B. The least (w.r.t. set inclusion) complete extension is the grounded extension. A stable extension is also a preferred extension and a preferred extension is also a complete extension. Stable, preferred and complete semantics admit multiple extensions whereas the grounded semantics ascribes a single extension to a given argument system. In the paper we want to to deal also with hard problems related to weighted AFs [1]. Formally, a weighted AF is a triple hArgs , R, wi where hArgs , Ri is a Dung-style abstract argument system, and w : R → R+ is a function assigning real valued weights to attacks. A key idea presented in [1] is the inconsistency budget, β ∈ R+ , which the authors use to characterise how much inconsistency they are prepared to tolerate. The intended interpretation is that, given an inconsistency budget β, we would be prepared to disregard attacks up to a total weight of β [1]. Conventional AFs implicitly assume an inconsistency budget of 0. Weighted AFs have been already modeled also in [12], by considering a semiring-based constraint programming framework. As shown in [1], while the the problem of finding the weighted version of the classical extensions (e.g. stable or admissible) is not computationally harder than the original problem, there are some important problems related to weighted grounded extensions that are very difficult to solve. The weighted AFs and the concept of inconsistency budget β have been introduced in Sec. II. In the following propositions, i.e. Prop. 1, Prop. 2 and Prop. 3, we show three complex problems proposed in [1]. As for preferred extensions, we say an argument is credulously accepted if it forms a member of at least one

weighted grounded extension, and sceptically accepted if it is a member of every weighted grounded extensions [1]. Since there are multiple β-grounded extensions [1], we can consider credulous and sceptical variations of the problem, as with preferred extensions. In Prop. 1 we consider the credulous case first: Proposition 1 ([1]): Given a weighted argument system hX, A, wi, an inconsistency budget β, and argument a ∈ X, the problem of checking whether ∃S ∈ wge(X, A, w, β) such that a ∈ S is NP-complete. In Prop. 2 we consider the “sceptical” version of the problem. Proposition 2 ([1]): Given a weighted argument system hX, A, wi, an inconsistency budget β, and an argument a ∈ X, the problem of checking whether, ∀Y ∈ wge(X, A, w, β), we have a ∈ Y is co-NP-complete. Suppose now we have a weighted argument system hX, A, wi and a set of arguments S. Then what is the smallest amount of inconsistency would we need to tolerate in order to make S a solution? [1] When considering conflictfree and admissible extensions, the answer is easy: we know exactly which attacks we would have to disregard to make a set of arguments admissible or consistent. However, when considering weighted grounded extensions, the answer is not so easy. There may be multiple ways of getting a set of arguments into a weighted extension, each with potentially different costs; we are thus typically interested in solving the problem expressed by Prop. 3: Proposition 3 ([1]): Given a weighted argument system hX, A, wi, a set of arguments S ⊆ X, and an inconsistency budget β, checking whether β is minimal w.r.t. hX, A, wi and S is co-NP-complete. III. C ONSTRAINT P ROGRAMMING The classic definition of a Constraint Satisfaction Problem (CSP) is as follows. A CSP P is a triple P = hX, D, Ci where X is an n-tuple of variables X = hx1 , x2 , . . . , xn i, D is a corresponding n-tuple of domains D = hD1 , D2 , . . . , Dn i such that xi ∈ Di , C is a t-tuple of constraints C = hC1 , C2 , . . . , Ct i. A constraint Cj is a pair hRSj , Sj i where RSj is a relation on the variables in Si = scope(Ci ). In other words, Ri is a subset of the Cartesian product of the domains of the variables in Si . A solution to the CSP P is an n-tuple A = ha1 , a2 , . . . , an i where ai ∈ Di and each Cj is satisfied in that RSj holds on the projection of A onto the scope Sj . In a given task one may be required to find the set of all solutions, sol(P ), to determine if that set is non-empty or just to find any solution, if one exists. If the set of solutions is empty the CSP is unsatisfiable. This simple but powerful framework captures a wide range of significant applications in fields as diverse as artificial intelligence, operations research, scheduling, supply chain management, graph algorithms, computer vision and computational linguistics [4].

One of the main reasons why constraint programming quickly found its way into applications has been the early availability of usable constraint programming systems, as JaCoP, which we will use in the implementation and solution of the AFs [6]. Various generalizations of the classic CSP model have been developed subsequently. One of the most significant is the Constraint Optimization Problem (COP) for which there are several significantly different formulations, and the nomenclature is not always consistent [4]. Perhaps the simplest COP formulation retains the CSP limitation of allowing only hard Boolean-valued constraints but adds a cost function over the variables, that must be minimized. A weighted constraint hc, wi is just a classical constraint c, plus a weight w (over natural, integer, or real numbers). The cost of an assignment t of the variable is the sum of all w(c), for all constraints c which are violated by t [4]. IV. M APPING AF S TO CSP S In this section we propose the mapping from AFs to CSPs, which is at the hearth of ConArg. A similar mapping (i.e. for weighted AFs) has been already described in [11]. Given an AF = hArgs , Ri, we define a variable for each argument ai ∈ Args (V = {a1 , a2 , . . . , an }) and each of these argument can be taken or not, i.e. the domain of each variable is D = {1, 0}. In the following explanation, notice that b attacks a means that b is a parent of a in the interaction graph, and c attacks b attacks a means that c is a grandparent of a. We need to define different sets of constraints: 1) Conflict-free constraints. Since we want to find the conflict-free sets, if R(ai , aj ) is in the graph we need to prevent the solution to include both ai and aj in the considered extension: ¬(ai = 1 ∧ aj = 1). The other possible assignment of the variables (a = 0 ∧ b = 1), (a = 1 ∧ b = 0) and (a = 0 ∧ b = 0) are permitted: in these cases we are choosing only one argument between the two (or none of the two) and thus, we have no conflict. 2) Admissible constraints. For the admissibility, we need that, if child argument ai has a parent node af but ai has no grandparent node ag (parent of af ), then we must avoid to take ai in the extension because it is attacked and cannot be defended by any ancestor: expressed with a unary constraint, ai = 0. Moreover, if ai has several grandparents ag1 , ag2 , . . . , agk and only one parent af (child of ag1 , ag2 , . . . , agk ), we need to add a k + 1-ary constraint ¬(ai = 1 ∧ ag1 = 0 ∧ · · · ∧ agk = 0). The explanation is that at least a grandparent must be taken in the admissible set, in order to defend ai from one of his parents af . Notice that, if a node is not attacked (i.e. he has no parents), he can be taken or not in the admissible set.

3) Complete constraints. To compute a complete extension B, we impose that each argument ai which is defended by B is in B, except those ai that, in such case, would be attacked by B itself [13]. This can be enforced by imposing that for each ai taken in the extension, also all its as1 , as2 , . . . , ask grandchildren (i.e. all the arguments defended by ai ), whose fathers are not taken in the extension, must be in B. Formally, (ai = 1∧as1 = 1∧· · ·∧ask = 1) only for those asi for which it stands that (af s1 = 0∧af s2 = 0∧· · ·∧af sz = 0), where af s1 , af s2 , . . . , af sz are the fathers of asi . 4) Stable constraints. If we have a child node ai with multiple parents af 1 , af 2 , . . . , af k , we need to add the constraint ¬(ai = 0∧af 1 = 0∧· · ·∧af k = 0). In words, if a node is not taken in the extension (i.e. ai = 0), then it must be attacked by at least one of the taken nodes, that is at least a parent of ai needs to be taken in the stable extension (that is, af j = 1). Moreover, if a node ai has no parent in the graph, it has to be included in the stable extension (notice ai cannot be attacked by nodes inside the extension, since he has no parent). The corresponding unary constraint is ¬(ai = 0). The following proposition states the equivalence between solving an AFS and its related CSP. Proposition 4 (Solution equivalence [11]): Given an AF = hArgs , Ri, the solutions of the related CSP obtained with the mapping corresponds to find over AF all the • conflict-free extensions by using conflict-free constraint classes. • admissible extensions by using conflict-free and admissible constraint classes. • complete extensions by using conflict-free, admissible and complete constraint classes. • stable extensions by using conflict and stable constraint classes. Notice that we can easily impose further requirements on the sets of arguments which are expected as extensions, like “extensions must contain argument a when they contain b” or “extensions must not contain one of c or d when they contain a but do not contain b” [14]. V. T HE C ONA RG T OOL In this section we present ConArg (Argumentation with Constraints) [5] a visual tool which randomly generates interaction graphs according to different small-world properties [15], [8]. After choosing the kind of graph, ConArg is able to solve to different (weighted) argumentation extensions on it. For the implementation we use two Java libraries, the Java Constraint Programming solver [6] (JaCoP) and the Java Universal Network/Graph Framework (JUNG) [7]. ConArg can also randomly generate interaction graphs by

Figure 2. Some of the possible extensions that can be found with ConArg.

choosing the attacks between arguments with a uniform distribution of probability. This distribution is also used to decide the weight of attacks (for the weighted AFs case). The last option is to create a reference graph used as example in [1]. JaCoP [6] is a Java library which provides the Java user with Finite Domain Constraint Programming paradigm [4]. It provides different type of constraints: most commonly used primitive constraints, such as arithmetical constraints, equalities and inequalities, logical, reified and conditional constraints, combinatorial (global) constraints. It provides a significant number of (global) constraints to facilitate an efficient modeling. It also provides a modular design of search to help the user on specific characteristics of the problem being addressed. To implement ConArg we also adopted JUNG [7], a software library for the modeling, generation, analysis and visualization of graphs. We suppose that interaction graphs, where nodes are arguments and edges are attacks (see Sec. II), represent a kind of social network, and consequently show the related small-world properties [8]. A practical example can be the study of discussion fora or social networks, where the users post their arguments that can attack other users’ arguments [8], [9], [10]. A first version of ConArg is downloadable as a Java NetBeans project, with all the source files [5]. A screenshot of the tool, where the user can choose different extensions to find, is shown in Fig 2. ConArg is able to find all conflict-free, admissible, complete and stable extensions by implementing in JaCoP the

constraints presented in Sec. IV. Moreover, it can find the preferred and grounded extensions as defined in Sec.II. In the following, we summarize the main implementation features for each kind of solvable problem (excluding those ones already explained in Sec. IV). Preferred Extensions: An interesting problem is determining whether a set of arguments is a preferred extension, which is a co-NP-complete [13] problem. Since a preferred extension S ∗ is a maximal (w.r.t. set inclusion) admissible subset of Args (see Sec. II), we can implement the search by finding an admissible extension S 0 such that S ∗ ⊂ S 0 ; if S 0 exists, then S ∗ is not a preferred extension, otherwise it is. The problem can be solved by assigning to 1 the variables representing the arguments in S ∗ , given as the input of the decidability problem. This ensures that the search procedure will try to find a superset of S ∗ . ConArg can i) find if a set of arguments passed by the user as input corresponds to a preferred extension or,ii) find all the preferred extensions. For the second option, we find all the admissible extensions with the highest number of taken arguments (ai = 1), and then a decision can be elaborated over this subset. Grounded Extensions: For this (single) extension, we use the constraints to find complete extensions, i.e. conflictfree, admissible and complete (see Sec. IV). Then, starting from the solutions with the lowest number of arguments, we check their intersection and if they are minimal w.r.t. set inclusion. α-conflict-free Extensions: ConArg can compute all the α-conflict-free extensions as proposed in [12]: Definition 6: (α-conflict-free [12]) A subset of the arguments B ⊆ Args is α-conflict-free if the sum of the weights for the attacksX between the arguments inside B is not greater than α, i.e. w(ai , aj) ≤ α. ai ,aj ∈B

To do so, first of all we need to extend our representation to include weighted constraints, as defined in Sec. III. The weighted constraints represent the costs associated to the attacks among the arguments in weighted AFs. To do so, we need to redefine the conflict-free constraints as proposed also in [12], thus leading to a weighted AF as defined in Sec. II, i.e. hArgs , R, wi. Since we want to find the conflict-free sets, if w(R(ai , aj )) = s is in the graph we need assign a s consistency budget to the solution that includes both ai and aj in the considered conflict-free extension: (ai = 1 ∧ aj = 1) = s. For the other possible assignment of the variables we have (a = 0 ∧ b = 1) = 0, (a = 1 ∧ b = 0) = 0 and (a = 0 ∧ b = 0) = 0, since these assignments are permitted with no cost also in the classical semantics: in these cases we are choosing only one argument between the two (or none of the two) and thus, we have no conflict. The easy way (if memory is not an issue) is to use ExtensionalConflict constraints [6]. In our implementation

we can specify, for example, an assignment [1, 1, 10] for three variables: the first two values states that if we take a1 and a2 in the same extension (i.e. a1 = 1 and a2 = 1), then the cost to be paid is represented by the third value (i.e. 10). In our model, this cost represents the cost associated to the attack between a1 and a2 . Since with this representation we need to specify different costs for any assignment of the considered variables, in general this extensional form could cause the system to run out of memory. However, for the weighted AF case it is easy and not memory-consuming to express all the costs of attacks in this way, since the variables can be assigned only to 0,1 and therefore there are four cases to define for each attack. Weighted Grounded Extensions [1]: To find all the following weighted problems, we use the conflict-free, admissible and complete constraints, since we look for βgrounded extensions. To check Prop. 1 we impose a = 1 (i.e. a must be present in the extension) and we have also to constrain the sum of the consistency budget β to be equal to the given β (i.e. cost = β). In Fig. 3 we show how ConArg is able to find the β-grounded with budget equal to 1, i.e. the solution to the problem described by Prop. 1. Only the attack between a3 and a4 can be removed, since it is the only edge with weight equal 1; this attack is represented by a dotted line in Fig. 3. The solution is highlighted by ConArg with gray nodes, i.e. it is {a2 , a4 , a6 , a7 }. We use the solution over the same interaction graph used in [1]. The other solution (not show in Fig. 3) is ∅, when removing no attacks from the graph. To check Prop. 2 we impose a constraint on the sum of the consistency budget to be equal to the given β (i.e. cost = β), and as soon as the find a β-grounded extension with a = 0 (i.e., the given a does not belong to a solution), we exit from the search procedure. We can then state that a does not belong to every solution with an inconsistency budget equal to β (Prop. 2); otherwise, the problem is satisfied To solve Prop. 3, we simply solve the CSP by minimizing cost and then to check if the found solution(s) have a cost value equal to the desired β consistency budget. JaCoP offers methods for finding a solution that minimizes a given cost function [6]. VI. P ERFORMANCE T ESTS In this section we test the ConArg tool presented in Sec. V. For the first tests we use the BarabasiAlbertGenerator class [7], [15], which is an evolving scale-free random graph generator. An example of such random graphs with 40 nodes is shown in Fig. 4. In the first tests we use a Depth First Search (DFS) algorithm [6], [4]: this algorithm searches for a possible solution by organizing the search space as a search tree. In every node of this tree a value is assigned to a domain

Nodes 10 40 60 100

Edges Conf-free (time) Admissible (time) 23 73 (317) 32 (307) 142 421.697 ('3min) 30.720 (3.193) 240 320.828 ('3min) 320.466 ('3min) 451 219.194 ('3min) 220.528 ('3min) Compl. (time) Stable (time) 29 (99) 1 (161) 3.108 (938) 1 (64) 3.104 (1.035) 2 (98) 377.610 ('3min) 1 (112)

Table I T HE TEST SMALL - WORLD NETWORK GENERATED WITH JUNG [7] AND THE CORRESPONDING STATISTICS ; TIME IS IN MILLISECONDS .

Figure 3. A β-grounded extension found with ConArg (with β = 1): {a2 , a4 , a6 , a7 }. The attack between a3 and a4 has been removed.

Figure 4. A small-world network with 40 nodes generated with JUNG by using the BarabasiAlbertGenerator class [7], [15].

variable and a decision whether the node will be extended or the search will be cut in this node is made. The search is cut if the assignment to the selected domain variable does not fulfill all constraints. Each time during the search, we select the variable which has most constraints assigned to it and we assign to it a random value from its current domain: we use MostConstrainedStatic() as the variable selection method and IndomainSimpleRandom() as the value selection

method, offered by JaCoP [6]. Moreover, we set a timeout of 180 sec. to interrupt the search procedure and to report the number of solutions found only in that interval; we run our experiments over 4 different sets of random graphs with 10, 40, 60 and 100 nodes. The performance in Tab. I reports the average results for each set of 5 different random graphs each. Each row in Tab. I shows the number of nodes and edges for the graphs and the average number of found conflict-free, admissible, complete and stable extensions; the time is measured in milliseconds. The implementation easily finds all the admissible extensions up to 40 nodes and complete extensions (which do not scale between 40 and 60 nodes) up to 60 nodes. Stable extensions, due to the characteristics of this kind of random scale-free network, are very few. The main problem is represented by finding all the conflict-free extensions, since we have problems already with 40 nodes: in fact, they represent the “less” constrained extension w.r.t. the others and, therefore, we have a higher number of them. However, we remind that these AFs contain at most 2|Args | extensions, thus the problem explodes very quickly for a given Args . To show how the performance can be improved, we also used a partial method, the Limited Discrepancy Search (LDS), which is a kind of Depth First Search procedure adopting the method proposed in [16]. If a given number of different decisions along a search path is exhausted, then backtracking is initiated [6], [16]. In Tab. II we show the improved results only for conflict-free and admissible extensions. With this method we can find up to five times more the number of extensions w.r.t. DFS, except for conflictfree extensions for graphs with 100 nodes: in this case the number of extensions is so huge that the LDS method performs as plain DFS within 3 minutes. In order to study our implementation on different networks, we have repeated the same tests for another kind of small-world network, the KleinbergSmallWorldGenerator [7]. An example of such graph is shown in Fig. 5. In Tab. III we report the performance collected with the same methodology as for Tab I. The higher number of found stable extensions w.r.t. complete ones in case of 100 nodes

Nodes 40 60 100

LDS n 30 40 451

Conf-free (time) 2.455.079 ('3min) 1.716.880 ('3min) 215.362 ('3min)

Admissible (time) 30.720 (3.120) 1.562.289 ('3min) 843.927 ('3min)

Table II T HE TEST SMALL - WORLD NETWORK GENERATED WITH JUNG [7] AND THE CORRESPONDING STATISTICS : TIME IS IN MILLISECONDS .

Figure 5. A small-world network with 36 nodes generated with JUNG by using the KleinbergSmallWorldGenerator class [7], [15].

can be justified with the fact that stable extensions are more constrained and therefore they are easier to find within the timeout of the search procedure (i.e. still 180 sec.). All the performance have been collected using a MacBook with 2.4Ghz Core Duo and 4Gb 1067Mhz DDR3 of RAM. VII. R ELATED W ORK In this work we propose a constraint-based tool, as suggested also in [11], [12] from the theoretical point of view, as an ideal framework where to solve AFs. ConArg can find all classical extensions [2] (as shown in Sec. IV) and hard problems related to weighted AFs [1] (as shown in Sec. V). Nodes 9 36 64 100

Edges Conf-free (time) Admissible (time) 45 22 (83) 12 (71) 180 411.317 (121.371) 5.1412 (8.511) 320 290.910 ('3min) 292.480 ('3min) 500 219.194 ('3min) 215.273 ('3min) Compl. (time) Stable (time) 8 (80) 6 (73) 525 (1.249) 449 (717) 92.725 (134.896) 63.878 (15.601) 49.787 ('3min) 58.728 ('3min)

Table III T HE TEST SMALL - WORLD NETWORK GENERATED WITH JUNG [7] AND THE CORRESPONDING STATISTICS : TIME IS IN MILLISECONDS .

In [1] no solving mechanism is proposed to solve the problems presented in the paper: the authors define the computationally hard problems and propose their complexity proofs, which inspired our idea of using the efficient solving techniques based on CP. In [17] crisp constraint have been used to model argumentation as constraint propagation in Distributed Constraint Satisfaction Problem (DSCP). Different agents represent the distributed points in the problem. The paper shows the appropriateness of constraints in solving large-scale argumentation systems. However, it seems to only solve classical problems, that is no weighted extensions. In [13] the authors model AFs with SAT [18]. An extensive survey of the difference between SAT and CP can be found in [18]: summarizing, CP is more expressive for the modeling phase in order to find more complex semantics and further user-defined constraints on classical semantics [14]. In addition, in CP the user has the possibility to inform the solver about problem specific information and then to appropriately tune it, while in SAT there is usually little room and need for this parametrization. Moreover the encoding presented in [13] has no practical implementation. In [19] the authors present an AF to CSPs mapping that is very similar to the one presented in [11], except that they deal with qualitative (and not quantitative) preferences. The are some frameworks based on Logic Programminglike languages. For example, the system ASPARTIX [20] is a tool for computing acceptable extensions for a broad range of formalizations of Dung’s argumentation framework and generalizations thereof, e.g. value-based AFs [21] or preference-based [22]. ASPARTIX relies on a fixed disjunctive datalog program which takes an instance of an argumentation framework as input, and uses the answer-set solver DLV for computing the type of extension specified by the user. However, ASPARTIX does not solve any quantitative argumentation case, as well as other Answer Set Programming systems [23]. As far as we know, all these implemented systems are not tested on large interaction graphs as we do in this paper, thus it is not possible to have an idea on how these systems scale over the number of arguments (for example). VIII. C ONCLUSIONS AND F UTURE W ORK We have presented ConArg, a constraint-based tool programmed in Java, which can solve several (weighted or not) problems related to AFs. We have proposed an unifying computational framework for Argumentation, with strong mathematical foundations and efficient solving techniques. ConArg is able also to solve some computationally hard extensions presented in [1]. In these problems, the attacks among arguments are weighted according some “strength”based criteria and it is possible to relax the classical Dung’s extensions up to a β budget value of tolerance on the attacks.

ConArg can randomly generate two different kinds of small-world networks [8]: AFs are solved over these kinds of graphs. As far as we know, in literature there is no example of practically finding Dung’s classical extensions over a small-world network. At last, we have tested ConArg on finding the Dung’s extensions (see Sec. VI). The performance show the efficiency of our tool: constraint solving techniques prove to be able to deal with large scale problems, even if the treated problems are difficult [4]. Practical applications of our framework may consist, for example, in automatically studying discussion fora [10] or social networks [9] where arguments are rated by users, thus, with large sets of arguments. For the future we have many open issues. We would like to investigate the properties of interaction graphs, in order to reproduce the tests we have presented in this paper on real interaction graphs (not only randomly generated). Moreover, we would like to compare the performance with other systems, as ASPARTIX [20]. A further intent is to directly program ad-hoc heuristic methods that can improve the performance during the search in the JaCoP solver. ACKNOWLEDGMENT Research was partially supported by MIUR PRIN 20089M932N project: “Innovative and multi-disciplinary approaches for constraint and preference reasoning”, by CCOS FLOSS project “Software open source per la gestione dell’epigrafia dei corpus di lingue antiche”, and by INDAM GNCS project “Fairness, Equit`a e Linguaggi”. R EFERENCES [1] P. E. Dunne, A. Hunter, P. McBurney, S. Parsons, and M. Wooldridge, “Weighted argument systems: Basic definitions, algorithms, and complexity results,” Artif. Intell., vol. 175, no. 2, pp. 457–486, 2011. [2] P. M. Dung, “On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games,” Artif. Intell., vol. 77, no. 2, pp. 321– 357, 1995. [3] S. Modgil, “Reasoning about preferences in argumentation frameworks,” Artif. Intell., vol. 173, no. 9-10, pp. 901–934, 2009. [4] F. Rossi, P. van Beek, and T. Walsh, Handbook of Constraint Programming (Foundations of Artificial Intelligence). New York, NY, USA: Elsevier Science Inc., 2006. [5] S. Bistarelli and F. Santini, “ConArg: Argumentation with constraints,” downloadable at http://www.dmi.unipg.it/ francesco.santini/argumentation/conarg.zip. [6] K. Kuchcinski and R. Szymanek, “JaCoP - Java Constraint Programming solver,” 2001, http://jacop.osolpro.com/. [7] J. O’Madadhain, D. Fisher, S. White, and Y. Boey, “The JUNG (Java Universal Network/Graph) framework,” UC Irvine, Tech. Rep., 2003.

[8] G. Ravid and S. Rafaeli, “Asynchronous discussion groups as small world and scale free networks,” First Monday, vol. 9, no. 9, 2004. [9] F. Toni and P. Torroni, “Bottom-up argumentation,” in First International Workshop on the Theory and Applications of Formal Argumentation (TAFA-11), 2011, pp. 291–303. [10] T. F. Gordon and N. I. Karacapilidis, “The zeno argumentation framework,” KI, vol. 13, no. 3, pp. 20–29, 1999. [11] S. Bistarelli, D. Pirolandi, and F. Santini, “Solving weighted argumentation frameworks with soft constraints,” in Recent Advances in Constraints, ser. LNCS, vol. 6384, 2009, pp. 1– 18. [12] S. Bistarelli and F. Santini, “A common computational framework for semiring-based argumentation systems,” in European Conference on Artificial Intelligence (ECAI10), 2010. [13] P. Besnard and S. Doutre, “Checking the acceptability of a set of arguments,” in Workshop on Non-Monotonic Reasoning, 2004, pp. 59–64. [14] S. Coste-Marquis, C. Devred, and P. Marquis, “Constrained argumentation frameworks,” in Knowledge Representation and Reasoning (KR). AAAI Press, 2006, pp. 112–122. [15] A. L. Barabasi and R. Albert, “Emergence of scaling in random networks,” Science, vol. 286, no. 5439, pp. 509–512, 1999. [16] W. D. Harvey and M. L. Ginsberg, “Limited discrepancy search,” in IJCAI (1), 1995, pp. 607–615. [17] H. Jung, M. Tambe, and S. Kulkarni, “Argumentation as distributed constraint satisfaction: applications and results,” in Conference on Autonomous agents (AGENTS). New York, NY, USA: ACM, 2001, pp. 324–331. [18] L. Bordeaux, Y. Hamadi, and L. Zhang, “Propositional satisfiability and constraint programming: A comparative survey,” ACM Comput. Surv., vol. 38, December 2006. [19] L. Amgoud and C. Devred, “Argumentation frameworks as constraint satisfaction problems,” in Scalable Uncertainty Management (SUM) - to appear, ser. LNCS. Springer, 2011. [20] U. Egly, S. A. Gaggl, and S. Woltran, “ASPARTIX: Implementing argumentation frameworks using answer-set programming,” in International Conference on Logic Programming (ICLP). LNCS, Springer, 2008, pp. 734–738. [21] T. J. M. Bench-Capon, “Persuasion in practical argument using value-based argumentation frameworks,” J. Log. Comput., vol. 13, no. 3, pp. 429–448, 2003. [22] L. Amgoud and C. Cayrol, “Inferring from inconsistency in preference-based argumentation frameworks,” J. Autom. Reasoning, vol. 29, no. 2, pp. 125–169, 2002. [23] J. C. Nieves, U. Cort´es, and M. Osorio, “Possibilisticbased argumentation: An answer set programming approach,” in Mexican International Conference on Computer Science(ENC). IEEE Computer Society, 2008, pp. 249–260.