Elsevier

Artificial Intelligence

Volume 300, November 2021, 103553
Artificial Intelligence

Incremental computation for structured argumentation over dynamic DeLP knowledge bases

https://doi.org/10.1016/j.artint.2021.103553Get rights and content

Abstract

Structured argumentation systems, and their implementation, represent an important research subject in the area of Knowledge Representation and Reasoning. Structured argumentation advances over abstract argumentation frameworks by providing the internal construction of the arguments that are usually defined by a set of (strict and defeasible) rules. By considering the structure of arguments, it becomes possible to analyze reasons for and against a conclusion, and the warrant status of such a claim in the context of a knowledge base represents the main output of a dialectical process. Computing such statuses is a costly process, and any update to the knowledge base could potentially have a huge impact if done naively. In this work, we investigate the case of updates consisting of both additions and removals of pieces of knowledge in the Defeasible Logic Programming (DeLP) framework, first analyzing the complexity of the problem and then identifying conditions under which we can avoid unnecessary computations—central to this is the development of structures (e.g. graphs) to keep track of which results can potentially be affected by a given update. We introduce a technique for the incremental computation of the warrant statuses of conclusions in DeLP knowledge bases that evolve due to the application of (sets of) updates. We present the results of a thorough experimental evaluation showing that our incremental approach yields significantly faster running times in practice, as well as overall fewer recomputations, even in the case of sets of updates performed simultaneously.

Introduction

Reasoning in argumentation-based systems is primarily carried out by weighing arguments for and against a conclusion or specific query. In structured argumentation, arguments are comprised of derivations that can make use of different kinds of rules and statements. In this paper, we adopt the Defeasible Logic Programming (DeLP) language [2], a logic programming-based approach in which knowledge bases, or programs, are composed of facts and rules, which can be either strict or defeasible.

Reasoning in DeLP is based on building a set of so-called dialectical trees and then marking their nodes based on their status in the dialogue—the main goal of this process is to arrive at a warrant status for a given literal. In general, one can be interested in keeping track of the warrant status of all literals involved in the program, allowing query answering to be optimized; in this scenario, an update to the DeLP program can have far-reaching effects, or perhaps none at all. Thus, a naive approach based on total recomputation of the warrant status of all literals after each update can lead to a significant amount of wasted effort. We are interested in tackling the problem of minimizing such wasted effort.

Structured argumentation frameworks. In [3], four frameworks that consider the structure of arguments are presented; two of them—ASPIC+ [4] and ABA [5], [6]—build the set of all possible arguments from the knowledge base and then rely on using one of the possible Dung semantics to decide on the acceptance of arguments; the other two—Logic-Based Deductive Argumentation [7] and DeLP [8]—only build the arguments involved in answering the query.

Given that our primary focus is on the changes in the structure of the arguments that are used to answer a query, we have focused on the DeLP language; however, the ideas developed here can be used to inspire similar techniques for other structured argumentation frameworks such as ASPIC+ and ABA, as will be discussed towards the end of Section 6. The last two frameworks mentioned above exhibit several differences [3]—among them is the base logic used as a knowledge representation language: [7] relies on propositional logic, requiring a theorem prover to solve queries, while DeLP [8] adopts an extension of logic programming, which is on the other hand a computational framework. For a better understanding of the differences among the above-mentioned frameworks, we refer the interested reader to [9], where a variant of DeLP using the grounded semantics is also discussed.

An important distinction between DeLP and the other three frameworks, which significantly affects the resolution of a query, rests on how attacks between arguments are described. As we will present below, DeLP considers two forms of defeat: proper and blocking; the former is akin to Dung's form of defeat, called attack in [10], whereas the latter behaves differently since the two arguments that are part of the blocking defeat relation, attacker and attackee, are defeated. Of course, this could be modeled in Dung's graphs as a mutual attack, but the DeLP mechanism forbids the use of two blocking defeaters successively because in a properly formed dialogue the introduction of another blocking defeater is unnecessary, since the first two are already defeated. Moreover, to find the answers required by the query, other considerations of dialogical nature are taken into account, which strengthens the reasoning process by forbidding common dialogical fallacies; these characteristics have been reflected in the development of a game-based semantics [11]. These considerations led us to the choice of DeLP as the basis of our research. It is interesting to note that the type of changes that could affect the knowledge base we study here from the algorithmic point of view seeking computational efficiency have been studied from the Belief Revision perspective in [12].

Contributions. With the aim of minimizing wasted effort in the computation of the warrant status of the literals of a DeLP program after performing an update, in this paper we make the following contributions:

  • We investigate the complexity of the problems of deciding the existence of an argument as well as deciding its status, showing that both problems are computationally hard—this motivates the investigation of incremental and efficient techniques.

  • We identify several cases in which single updates or sets of updates to be performed simultaneously are guaranteed to have no effect, i.e., these updates are irrelevant, in the sense that the status of the literals does not change after performing such kinds of updates.

  • We propose an approach based on the construction of a reachability hypergraph in order to keep track of literals that are potentially affected by a given update (namely, influenced and core literals), which leads to an incremental computation algorithm that focuses only on these literals and avoids the computation of the status of inferable and preserved literals.

  • We empirically evaluate our approach, showing that it can lead to significant savings in running time for single updates consisting of rule addition/removal, as well as for multiple updates applied simultaneously.

Given the number of real-world applications of argumentation systems that are being implemented, the area concerned with the computational approaches to argumentation is requiring the attention of the research community. There is a significant effort to develop abstract argumentation solvers that show considerable success [13]; the immediate effect of these accomplishments can be seen in the systems that use this approach. Several lines of research have already examined the dynamics of argumentation following belief revision techniques over abstract argumentation,1 which are not looking at the structure of arguments. Our work is based on a system that directly implements a semantics for computing answers, i.e., it is concerned with deciding the status of a literal after a particular change in the knowledge base (program), looking to improve performance.

Organization. After briefly reviewing Defeasible Logic Programming (DeLP ) in Section 2, where the notion of update is also presented, we introduce the concept of (labeled) hypergraph associated with a DeLP program, and investigate the complexity of problems related to the computation of the status of arguments in Section 3. Next, in Section 4 we present our incremental technique that deals with sets of updates applied simultaneously. The benchmark generator and the experimental evaluation covering both efficiency and effectiveness is presented in Section 5. Related work is discussed in Section 6, and the paper is concluded in Section 7, where future work is outlined. To facilitate readability, proofs of the results stated in the paper are reported in Appendix A.

Section snippets

Defeasible logic programming and updates

We first briefly review the syntax and semantics of Defeasible Logic Programming (DeLP )—the interested reader can find a thorough description of this formalism in [2]. After this we introduce the notion of updates for DeLP programs.

We assume the existence of a set

of atoms from which DeLP programs can be built. A literal is a ground atom
or its negation ∼α, where symbol “~” represents strong negation; the formula α can be used for denoting α. We use Lit to denote the set of

Labeled hypergraphs for DeLP programs and complexity analysis

In this section, we first introduce the concept of labeled hypergraph associated with a DeLP program. This structure will be used both in the complexity analysis provided in this section as well as in several definitions that make up the basis of our incremental approach.

Recall that a directed hypergraph is a pair N,H, where N is the set of nodes and H(2N)×N is the set of hyper-edges. For hyper-edge (S,t), S is a non-empty set called the source set, while t is called the target node.

The

Incremental computation

We now address the problem of recomputing the status SP of the literals w.r.t. an updated program P=U(P), given P with status SP. Whenever the status of a literal α does not change, i.e., SP(α)=SP(α), we say that (the status of) α is preserved. Establishing whether the status of literals occurring in a DeLP program is preserved can be carried out by recomputing it from scratch. However, for some literals, this can be avoided or made more efficient by considering only a restricted portion of

Implementation and experiments

In this section we report on a set of experiments designed to compare our incremental approach (Algorithm 1) against recomputation from scratch (i.e., the direct computation of the status of all the literals in an updated DeLP program using the DeLP -Solver). We performed experiments that aimed at evaluating both the efficiency and effectiveness of our approach on two datasets:

  • Real, consisting of a set of DeLP programs built from the knowledge base used by the music recommender system proposed

Related work

Overviews of key concepts in argumentation theory and formal models of argumentation can be found in [28], [29], [30], [31]. Further discussion regarding the uses of computational argumentation as an Agreement Technology can be found in Modgil et al. [32].

Several significant efforts dealing with dynamic aspects of abstract argumentation frameworks have been developed (e.g., [33], [34], [35]), where arguments are abstract entities with no internal structure [10]. The techniques proposed in [23],

Conclusions and future work

We have addressed the problem of avoiding wasted effort when determining the warrant status of literals in a DeLP program after it is changed by applying a set of strict/defeasible rule additions and deletions. We identified certain conditions under which single or multiple updates can be guaranteed to have no effect whatsoever, and then proposed a data structure that helps us determine the potential effects of the update, thus allowing us to conclude that the rest of the literals will be

CRediT authorship contribution statement

All authors have participated in (a) conception and design, or analysis and interpretation of the data; (b) drafting the article or revising it critically for important intellectual content; and (c) approval of the final version.

This manuscript has not been submitted to, nor is under review at, another journal or other publishing venue.

Declaration of Competing Interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

Acknowledgements

The authors are grateful to the participants of the workshop Current Trends in Formal Argumentation (held at the University Centre of Bertinoro from November 3rd to 6th, 2019) for discussions on the topic of this paper. Special thanks to Matthias Thimm for pointing out limitations of the technique previously presented in [1] that led to a more complete theoretical analysis and characterization of the irrelevant updates, and of the set of influenced literals, which are at the basis of our

References (56)

  • G. Governatori et al.

    Revision of defeasible preferences

    Int. J. Approx. Reason.

    (2019)
  • G. Alfano et al.

    An incremental approach to structured argumentation over dynamic knowledge bases

  • A.J. García et al.

    Defeasible logic programming: an argumentative approach

    Theory Pract. Log. Program.

    (2004)
  • P. Besnard et al.

    Introduction to structured argumentation

    Arg. Comput. – Special Issue: Tutorials on Structured Argumentation

    (2014)
  • S. Modgil et al.

    The ASPIC+ framework for structured argumentation: a tutorial

    Arg. Comput.

    (2014)
  • A. Bondarenko et al.

    An assumption-based framework for non-monotonic reasoning

  • F. Toni

    A tutorial on assumption-based argumentation

    Arg. Comput.

    (2014)
  • P. Besnard et al.

    Constructing argument graphs with deductive arguments: a tutorial

    Arg. Comput.

    (2014)
  • A.J. García et al.

    Defeasible logic programming: DeLP-servers, contextual queries, and explanations for answers

    Arg. Comput.

    (2014)
  • A.J. Garcia et al.

    A comparative study of some central notions of ASPIC+ and DeLP

    Theory Pract. Log. Program.

    (2019)
  • P.M. Dung

    On the acceptability of arguments and its fundamental role in nonmonotonic reasoning, logic programming and n-person games

    Artif. Intell.

    (1995)
  • I.D. Viglizzo et al.

    The foundations of DeLP: defeating relations, games and truth values

    Ann. Math. Artif. Intell.

    (2009)
  • M.O. Moguillansky et al.

    Dynamics of knowledge in DeLP through argument theory change

    Theory Pract. Log. Program.

    (2013)
  • M.A. Falappa et al.

    On the evolving relation between belief revision and argumentation

    Knowl. Eng. Rev.

    (2011)
  • F. Stolzenburg et al.

    Computing generalized specificity

    J. Appl. Non-Class. Log.

    (2003)
  • G. Alfano et al.

    On the semantics of abstract argumentation frameworks: a logic programming approach

    Theory Pract. Log. Program.

    (2020)
  • S. Greco et al.

    Efficient computation of deterministic extensions for dynamic abstract argumentation frameworks

  • G. Alfano et al.

    Efficient computation of extensions for dynamic abstract argumentation frameworks: an incremental approach

  • Cited by (19)

    • Approximating stability for applied argument-based inquiry

      2022, Intelligent Systems with Applications
      Citation Excerpt :

      Note that we do not claim that each sound and complete algorithm for computing stability is as slow as Stability-naive. We can imagine several improvements on the algorithm, such as only considering those unknown queryables that influence a particular literal for which we want to know the stability status (see Alfano et al., 2021 for a comparable approach on a related problem) and/or more efficient searching by SAT-based approaches (similar to Niskanen and Järvisalo, 2020). However, algorithms based on these ideas do not yet exist for ASPIC+ and implementing these improvements is beyond the scope of this paper.

    • Abstract Argumentation Framework with Conditional Preferences

      2023, Proceedings of the 37th AAAI Conference on Artificial Intelligence, AAAI 2023
    • Argumentative Reasoning in ASPIC<sup>+</sup> under Incomplete Information

      2023, Proceedings of the International Conference on Knowledge Representation and Reasoning
    View all citing articles on Scopus

    This paper is a substantially revised and expanded version of [1].

    View full text