**2. Preliminaries**

Tools developed in the area of argumentation-based reasoning offer the possibility of analyzing complex and dynamic domains by studying the arguments for and against a conclusion. Specifically, *defeasible argumentation* leverages models that contain inconsistency, evaluating arguments that support contradictory conclusions and deciding which ones to keep [20]. An argument supports a conclusion from a set of premises [20]; a conclusion C constitutes a piece of tentative information that an agent is willing to accept. If the agent then acquires new information, conclusion C, along with the arguments that support it, could be invalidated. The validity of a conclusion C is guaranteed when there is an argument that provides justification for C that is undefeated. This process involves the construction of

an argument A for C, and the analysis of counterarguments that are possible defeaters of A; as these defeaters are arguments, it must be verified that they are not themselves defeated. There are several formalisms that are based on this idea, such as ABA [21], ASPIC+ [22], *defeasible logic programming* (DeLP) [23], and *deductive argumentation* [24], which consider the structure of the arguments that model a discussion. The DAQAP platform [19] on which the presented system is based uses DeLP as its central formalism. We now briefly present the necessary background, starting with DeLP and its probabilistic extension.

#### *2.1. Defeasible Logic Programming (DeLP)*

DeLP combines logic programming and defeasible argumentation. A DeLP program P, also denoted as (Π, Δ), is a set of facts and strict rules (Π), and defeasible rules (Δ). *Facts* are ground literals representing atomic information (or its negation using strong negation "∼"), *strict rules* represent nondefeasible information, and *defeasible rules* represent tentative information. Here, we consider the extension that incorporates *presumptions* to set Δ, which can be thought of as a kind of defeasible fact [25].

The dialectical process used in deciding which information prevails as *warranted* involves the construction and evaluation of arguments that either support or interfere with the query under analysis. An *argument* A is a minimal set of defeasible rules that, along with the set of strict rules and facts, are not contradictory and derive a certain conclusion *α*, denoted as A, *α*. Arguments supporting the answer for a query can be organized using *dialectical trees*. A query is issued to a program (Π, Δ) in the form of a ground literal *α*.

A literal *α* is *warranted* if there exists a nondefeated argument A supporting *α*. To establish if A, *α* is a nondefeated argument, *defeaters* for A, *α* are considered, *i.e.*, *counterarguments* that by some criteria are preferred to A, *α*. An argument A<sup>1</sup> is a counterargument for A<sup>2</sup> *iff* A<sup>1</sup> ∪ A<sup>2</sup> ∪ Π is contradictory. Given a preference criterion, and an argument A<sup>1</sup> that is a *defeater* for A2, A<sup>1</sup> is called a *proper defeater* if it is preferred to A2, or a *blocking defeater* if it is equally preferred or is incomparable with A2. Since there may be more than one defeater for a particular argument, many acceptable argumentation lines could arise from one argument, leading to a tree structure. This is called a *dialectical tree* because it represents an exhaustive dialectical analysis for the argument in its root; every node (except the root) represents a defeater of its parent, and leaves correspond to nondefeated arguments. Each path from the root to a leaf corresponds to a different acceptable argumentation line. A dialectical tree provides a structure for considering all possible acceptable argumentation lines that can be generated for deciding whether an argument is defeated.

Given a literal *α* and an argument A, *α* from a program P, to decide whether *α* is warranted, every node in the tree is recursively marked as *D* (*defeated*) or U (*undefeated*), obtaining a marked dialectical tree TP(A): (1) all leaves in TP(A) are marked as "U"s; and (2) let B be an inner node of TP(A); then, B is marked as U *iff* every child of B is marked as D. Thus, node B is marked as D *iff* it has at least one child marked as U. Given an argument A, *<sup>α</sup>* obtained from P, if the root of TP(A) : is marked as U, then TP(A) *warrants <sup>α</sup>*, and *α* is *warranted* from P. The DeLP interpreter takes a program P and a DeLP query *L*, and returns one of the following four possible answers: YES if *L* is warranted from P, NO if the complement of *L* regarding strong negation is warranted from P, UNDECIDED if neither *L* nor its complement are warranted from P, or UNKNOWN if *L* is not in the language of the program P.
