Handling Dynamic Aspects of Argumentation

Many applications in the field of artificial intelligence aim to reproduce human behaviour and reasoning in order to allow machines to think and act accordingly. One of the main challenges in this sense is to provide methodologies and tools for expressing a certain kind of knowledge in a formal way so that the machines can use it for reasoning and infer new information. Argumentation pursues the objective of studying how conclusions can be reached, starting from a set of assumptions, through a process of logical reasoning. This process is very similar to the human way of thinking and involves features which can be traced to the conducting of a dialogue between two (or more) people. Indeed, in the most common form of argumentation, a part (which can be, for instance, an interlocutor) in a debate tries to affirm some belief and defends it from the attacks of other parts. Argumentation Theory provides formal models for representing and evaluating arguments that interact with each other and, in particular, Abstract Argumentation Frameworks (AFs) are used to study the acceptability of arguments. Solving an abstract argumentation problem means to identify components of the debate (called extensions) which share certain properties and validate the same proposition, according to a specified semantics (which is a selection criterion). Besides the static representation of conflicts between different parts, AFs can also handle the evolution of situations in which instances of particular problems undergo changes; variations on the underlying information can be interpreted as modifications in the corresponding framework. Practical implementation of argumentation-based systems should take into account the various changes that are usually introduced in a given knowledge base. The case in which all the information is already known to every party at the beginning of the interaction and thus the conclusion can be drawn without any further step is, indeed, unlikely. Moreover, due to the dynamic nature of certain problems, settling for a solution (in a particular AF) could not be sufficient to guarantee a good outcome in case the problem evolves. In this thesis, we study the dynamics of AFs from multiple perspectives with the purpose of better understanding how dynamic (and concurrent) processes can be handled in the context of argumentation. In this sense, we provide theoretical results, algorithms and tools which can be useful in many dynamic aspects of argumentation. Before arriving to define our concurrent language, we set the theoretical results we need to work with dynamics aspect of argumentation. First, we consider aspects of argumentation oriented towards reasoning tasks, as operations that preserve the semantics and ranking functions for the arguments. We start by investigating some of the problems that can be instantiated in argumentation-based systems and involve a reasoning process to accomplish a given task. As one can expect, introducing changes might lead to obtaining different semantics for the considered AF. We therefore study operations which leave the set of extensions unchanged and we arrive to define a set of operators for which the semantics is an invariant. We also derive a notion of robustness representing the number of syntactical changes an AF can withstand before changing its semantics. When the number of arguments to take into account is very large, restricting to the set of accepted arguments may still not be sufficient to make a decision concerning a certain problem. Using ranking-based semantics, instead, it is possible to refine the acceptability level of arguments in an AF by sorting them from the best to the worst, according to some evaluation method. We give our contribution to the field by devising a ranking-based semantics that relies on power indexes for estimating the contribution a certain argument brings to each extension. Aware of the fact that abstract frameworks are not sufficient to precisely instantiate problems coming from the real world, for which the structure of the arguments as well as the type of relations between them should be considered, we study the behaviour of ranking-based semantics in a setting where AFs are semi-structured: we use claim-augmented frameworks in which arguments are explicitly associated with the claims they stand for. The work is accompanied by a study of the properties that characterise the various ranking functions. Then we set the basis for working with the acceptability of arguments both for the classical and the weighted case through four-state labelling-based semantics. Whatever the level of abstraction, the central task in applications that take advantage of argumentation theory is the identification of good arguments: the first step to (be able to) draw conclusions in a controversial situation or when the information is only partial is to separate an acceptable outcome from the rest of non-feasible solutions. Between classical semantics which only distinguish acceptable arguments from rejected ones and ranking-based semantics that just sort the arguments from the best to the worst, labelling-based semantics allow for discriminating up to three statuses of acceptance by assigning labels to the arguments in an AF. In this thesis, we adapt the classical three-state labelling semantics to work with the extra label that we use to mark "unused" arguments in the framework. We also consider the weighted case, in which AFs are extended with values on the attack relations representing the strength of the attacks themselves and we provide labelling functions that generalise the classical approach. We continue proposing a language able to describe the interactions between debating agents and that uses argumentation as an embedded reasoning engine. Logical frameworks for argumentation have been introduced to fulfil the operational tasks related to the study of dynamics in AFs, such as the description of AFs, the specification of modifications, and the search for sets of ``good'' arguments. Since none of these approaches consider the possibility of having concurrent interactions or agents arguing with each other, we introduce a concurrent language for argumentation (ConArg_lang) that aims to be used also for modelling different types of interaction between agents (as negotiations, persuasion, deliberation and dialogues). In particular, our language allows for modelling concurrent processes, inspired by notions such as the Ask-and-Tell constraint system and using AFs as a centralised store. The language is thus endowed with primitives for the specification of interaction between agents through the fundamental operations of adding (or removing) and checking arguments and attacks. We also propose a set of AGM-style operations that allow for modifying an AF (which constitutes the shared memory our agents access to communicate) and changing the status of its arguments to allow the implementation of more complex operations, like negotiation and the other forms of dialogues. Finally, we accompany all our theoretical results with working implementations of tools that are used to both better study the problems we face and prepare the ground for practical applications. The core of the suite consists of a constraint-based solver for AFs, able to compute the set of extensions and test the acceptability of the arguments. The solver can work with classical as well as extended AFs, like weighted and probabilistic ones. Among other functionalities, we provide the possibility to rank the arguments of a given framework using power indexes from cooperative game theory. The suite is also endowed with a web interface in which graphical representations of AFs, labelling semantics and ranking of arguments can be visualised.