Argumentation Frameworks (AFs) are used, in the field of Artificial Intelligence, to evaluate the justification state of conflicting information, thus allowing the development of automatic reasoning techniques and systems. Complex argumentative processes, such as decision-making and negotiation, which take place over time (usually marked by shifts in which two or more counterparts exchange their opinions), can be modelled through the Concurrent Language for Argumentation, a formalism for handling concurrent interactions between intelligent agents that use an AF as shared memory. In this paper, we first show how AFs can be interpreted as dependency graphs by exploiting the causal relation between arguments induced by the attacks. Then, we describe a methodology for obtaining a procedure that generates the given AF. Such a procedure allows to dynamically represent dialogues and other forms of interaction that brought to the instantiation of the specific AF. The dependency graph also provides an explanation for the acceptance/rejection of a given argument: the path from a leaf to a root of the underlying graph can be seen as a motivation for the assigned justification state.
Argumentation Theory [
The purpose of this paper is twofold. First, we use the causal relation between the arguments of an AF induced by attacks (the attacking argument must have been brought forward in the reasoning after the attacked argument) to interpret AFs as dependency graphs, namely structures that describe the dependencies between their elements. In particular, attacking arguments will depend on the attacked ones. Considering this type of dependency, we can derive the order in which the arguments are presented, thus obtaining a potential description of how the instantiation of the AF took place. Then, we show how AFs can be generated through the Concurrent Language for Argumentation (cla), a language able to model interactions between intelligent agents which communicate and reason through a shared AF. A cla program is given as a series of actions to perform for building the target AF. In this short paper, we restrict the study to acyclic graphs.
We briefly recall the fundamental notions of AFs and argumentation semantics. Definition 1 (AFs). An Abstract Argumentation Framework is a pair ⟨, ⟩ where is a ifnite set of arguments and is a binary relation on .
For two arguments , ∈ , the notation (, ) ∈ represents an attack directed from
against . Moreover, we denote as + and − the set of attacks respectively incoming into and
outgoing from . A notion of defence can be used as a criterion for distinguishing acceptable
sets of arguments (extensions) in the framework [
Definition 2 (Defended Argument). Given an AF = ⟨, ⟩, an argument ∈ is acceptable with respect to ⊆ if and only if ∀ ∈ such that (, ) ∈ , ∃ ∈ such that (, ) ∈ , and we say that is defended from .
The Concurrent Language for Argumentation (cla) [
In addition to modelling conflicts in AFs, attacks between arguments also establish a causal relationship between the arguments themselves. Consider an AF = ⟨, ⟩ with two arguments , ∈ and the attack relation (, ) ∈ . We interpret this attack as a conflict between the two arguments, with the further knowledge that is the argument from which the attack against starts. This means that is specifically introduced into the framework to contrast argument and undermine its validity. In the case was not present from the beginning, would have no reason to be part of the AF and this fact allows us to identify a causal relation between and . In our example, the existence of is preliminary to that of , so we can say that depends on .
Following these considerations, an AF can be interpreted as a dependency graph, i.e. a directed graph representing the dependencies of various elements (in our case, arguments). Formally, a dependency graph is a couple = (, ) where is a set of elements and the transitive reduction of a relation ⊆ × . In a dependency graph, one can look for an evaluation order respecting the given dependencies. A correct evaluation order is a numbering that orders two elements and in such a way that if is evaluated before , then must not depend on . For example, the element corresponding to argument in Figure 1 should come before and in a correct evaluation order of the represented graph, while should come before and after both and .
Finding a correct evaluation order for a dependency graph amounts to reconstructing the reasoning process that leads to the generation of an AF superseding the same graph. Indeed, AFs represent conflicting information and they can be seen as the instantiation of an argumentative process between intelligent agents. In the real world, such kinds of processes take place over time and can be imagined as a succession of statements made by one or more counterparties, with the various statement referring to (attacking) each other. The beginning of this argumentative process is to be found, therefore, in the leaves of the AF, which, not attacking any other argument, must be the first sentences that started the process.
cla Using the constructs of cla, we can realise procedures able to generate AFs by modifying the shared store, which will take the shape of a desired AF. In this preliminary study, we only take into account acyclic AFs, (giving some hints on how to deal with cycles in the concluding section). For example an AF like the one illustrated in Figure 1 can be obtained as a result of the following cla procedure, which can also be executed through our web interface.1 checkw({},{}) -> add({a},{}) -> checkw({a,c},{}) -> add({b},{(b,a),(b,c)}) ->
checkw({b},{}) -> add({d},{(d,b)}) -> success || checkw({a},{}) -> add({c},{(c,a)}) -> success 1Link to cla web interface: https://conarg.dmi.unipg.it/cla.
The operation ℎ(, ) verifies if the given subsets of arguments and attacks
belong to the shared store, while (, ) inserts and into the AF; the execution, then,
terminates with a (for a detailed discussion of cla operations, the reader is referred
to [
Algorithm 1: AFs generation through cla
Data: AF = ⟨, ⟩, ⊆ , string
Result: cla program 1 procedure AFtoProg( ,,): 2 foreach in do 3 if is not discovered then 4 mark as discovered 5 if is the only discovered node in then 6 = + “checkw(a+,{}) -> add({a},{(, ) | ∈ +)}) -> ” 7 else 8 = + “|| checkw(a+,{}) -> add({a},{(, ) | ∈ +)}) -> ” 9 if − is empty then 10 = + “success” 11 else 12 AFtoProg( ,− ,)
The recursive procedure AFtoProg in Algorithm 1 takes in input an AF , a subset of argument and a string which at the end of the execution will contain the desired cla program. The set initially contains the leafs of the AF. All the elements in are processed (line 2) and only if they have not been visited yet, the procedure continues (line 3). Nodes are marked as discovered in line 4 and then are added into the cla program. If there are no other discovered nodes in apart from the one being visited (let us call it ), we first check that all the arguments attacked by have already been added, and then we also add with all its outgoing attacks (lines 5 − 6). If is not the only discovered nodes, we build the same cla process, this time adding the parallel construct at the beginning (lines 7 − 8). In lines 9 − 10 we have the terminal case: whenever we reach a root in the AF, we make the (branch of the) cla program terminate with success. If the visited node has incoming attacks, we recursively call AFtoProg passing the attackers of as a parameter (lines 11 − 12).
We studied AFs from the perspective of dependency between arguments. We first showed how causality can be derived from the attack relations, allowing us to interpret an AF as a dependency graph in which arguments depend on those they attack. Second, we resorted to cla constructs for obtaining a program which generates a desired AF. The advantage of producing an AF in this way lies in the fact that, by reading the trace of the cla program, it is possible both to reconstruct the process that generated the AF and to obtain an explanation for the justification state assigned to the various arguments.
In this paper, we conducted a preliminary investigation of various aspects related to the
similarity between dependency graphs and AFs, and in the future, we plan to deepen this study
under several aspects. First of all, we want to remove the constraints on the AF structure that
we have imposed in the current work. To generalise our approach also to AFs with cycles,
we want to devise a methodology for selecting a set of initial arguments for the procedure of
Algorithm 1 even when there are no non-attacked arguments. In particular, we plan to use the
Kosaraju-Sharir’s algorithm [