Graphical Representation of Assumption-Based Argumentation

The existing approaches which map the given explicit preferences into standard assumption-based argumentation frameworks (ABAs) reveal some difficulties such as generating a huge number of rules and so on. To overcome them, we present an assumption-based argumentation framework equipped with preferences (p_ABA). It increases the expressive power of ABA by incorporating preferences between sentences into the framework. The semantics of p_ABAs is given by \(\mathcal{P}\) extensions selected from extensions of ABAs based on the given sentence ordering. The advantages of our approach are that not only it enables us to express different kinds of preferences such as preferences over rules, over goals, over decisions by means of sentence orderings in p_ABAs but we also successfully obtain solutions from \(\mathcal{P}\) extensions of the p_ABAs expressing the respective knowledge for various applications such as epistemic reasoning, practical reasoning, decision-making with preferences and so on in a uniform way without suffering from difficulties of existing ones.

The study of computational models for argumentation is a vibrant area of artificial intelligence and, in particular, knowledge representation and reasoning research. Arguments most often have an intrinsic structure made explicit through derivations from more basic structures. Computational models for structured argumentation enable making the internal structure of arguments explicit. Assumption-based argumentation (ABA) is a central structured formalism for argumentation in AI. In this article, we make both algorithmic and complexity-theoretic advances in the study of ABA. In terms of algorithms, we propose a new approach to reasoning in a commonly studied fragment of ABA (namely the logic programming fragment) with and without preferences. While previous approaches to reasoning over ABA frameworks apply either specialized algorithms or translate ABA reasoning to reasoning over abstract argumentation frameworks, we develop a direct declarative approach to ABA reasoning by encoding ABA reasoning tasks in answer set programming. We show via an extensive empirical evaluation that our approach significantly improves on the empirical performance of current ABA reasoning systems. In terms of computational complexity, while the complexity of reasoning over ABA frameworks is well-understood, the complexity of reasoning in the ABA+ formalism integrating preferences into ABA is currently not fully established. Towards bridging this gap, our results suggest that the integration of preferential information into ABA via so-called reverse attacks results in increased problem complexity for several central argumentation semantics.

Assumption-based argumentation can serve as an effective computational tool for argumentation-based epistemic and practical reasoning, as required in a number of applications. In this paper we substantiate this claim by presenting formal mappings from frameworks for epistemic and practical reasoning onto assumption-based argumentation frameworks. We also correlate these mappings to formulations of epistemic and practical reasoning in abstract argumentation terms.KeywordsPractical ReasoningInference RuleLogic ProgrammingDeductive SystemStrict RuleThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Logic Programming and Argumentation Theory have been existing side by side as two separate, yet related, techniques in the field of Knowledge Representation and Reasoningfor many years.When Assumption-Based Argumentation (ABA) was first introduced in the nineties,the authors showed how a logic program can be encoded in an ABA framework andproved that the stable semantics of a logic program corresponds to the stable extension semantics of the ABA framework encoding this logic program.We revisit this initial work by provingthat the 3-valued stable semantics of a logic program coincides with the complete semantics of the encoding ABA framework,and that the L-stable semantics of this logic program coincides with the semi-stable semantics of the encoding ABA framework.Furthermore, we show how to graphically represent the structure of a logic program encoded in an ABA frameworkand that not only logic programming and ABA semanticsbut also Abstract Argumentation semantics can be easily applied to a logic program using these graphical representations.

Three-valued completion for abductive logic programs

In his paper [12] Ross extends the well-founded semantics for normal logic programs [16] to disjunctive logic programs. His definition is top-down and it is closer to a procedural semantics than to the elegant fixpoint definition of the well-founded semantics for normal logic programs. In the present paper, we propose a declarative, bottom-up fixpoint definition of the well-founded semantics for disjunctive logic programs. Our construction of the greatest unfounded set of extended literals is similar with the construction of the greatest unfounded set for normal programs. As a consequence, the connection between the well-founded semantics for normal programs and the well-founded semantics for disjunctive programs is made clearer.KeywordsLogic ProgramDeductive DatabaseNormal ProgramDisjunctive ProgramExtended AtomThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

M. Bezem defined an extensional semantics for positive higher-order logic programs. Recently, it was demonstrated by Rondogiannis and Symeonidou that Bezem's technique can be extended to higher-order logic programs with negation, retaining its extensional properties, provided that it is interpreted under a logic with an infinite number of truth values. Rondogiannis and Symeonidou also demonstrated that Bezem's technique, when extended under the stable model semantics, does not in general lead to extensional stable models. In this paper, we consider the problem of extending Bezem's technique under the well-founded semantics. We demonstrate that the well-founded extensionfailsto retain extensionality in the general case. On the positive side, we demonstrate that for stratified higher-order logic programs, extensionality is indeed achieved. We analyze the reasons of the failure of extensionality in the general case, arguing that a three-valued setting cannot distinguish between certain predicates that appear to have a different behaviour inside a program context, but which happen to be identical as three-valued relations.

Most of the theoretical work on the semantics of logic programs assumes an interpreter that provides a complete resolution procedure. In contrast, for reasons of efficiency, most logic programming languages are built around incomplete procedures. This difference is rooted in Prolog, which evaluates resolvent trees in a depth-first rather than a breadth-first order. The gap is widened by some equational logic languages, which combine the incompleteness of depth-first evaluation with incomplete approximations to equational unification. Because of this gap, it is unsound to reason about logic programs using their declarative semantics. This in turn makes it difficult to develop abstraction mechanisms that can be used to partition a logic program into independently specifiable modules.

The logic program formalism is commonly viewed as a modal or default logic. In this paper, we propose an alternative interpretation of the formalism as a terminological logic. A terminological logic is designed to represent two different forms of knowledge. A TBox represents definitions for a set of concepts. An ABox represents the assertional knowledge of the expert. In our interpretation, a logic program is a TBox providing definitions for all predicates; this interpretation is present already in Clark's completion semantics. We extend the logic program formalism such that some predicates can be left undefined and use classical logic as the language for the ABox. The resulting logic can be seen as an alternative interpretation of abductive logic program formalism. We study the expressivity of the formalism for representing uncertainty by proposing solutions for problems in temporal reasoning, with null values and open domain knowledge.

Over recent years, various semantics have been proposed for dealing with updates in the setting of logic programs. The availability of different semantics naturally raises the question of which are most adequate to model updates. A systematic approach to face this question is to identify general principles against which such semantics could be evaluated. In this paper we motivate and introduce a new such principle – the refined extension principle – which is complied with by the stable model semantics for (single) logic programs. It turns out that none of the existing semantics for logic program updates, even though based on stable models, complies with this principle. For this reason, we define a refinement of the dynamic stable model semantics for Dynamic Logic Programs that complies with the principle.

This paper studies the stable model semantics of logic programs with (abstract) constraint atoms and their properties. We introduce a succinct abstract representation of these constraint atoms in which a constraint atom is represented compactly. We show two applications. First, under this representation of constraint atoms, we generalize the Gelfond–Lifschitz transformation and apply it to define stable models (also called answer sets) for logic programs with arbitrary constraint atoms. The resulting semantics turns out to coincide with the one defined by Son et al. (2007), which is based on a fixpoint approach. One advantage of our approach is that it can be applied, in a natural way, to define stable models for disjunctive logic programs with constraint atoms, which may appear in the disjunctive head as well as in the body of a rule. As a result, our approach to the stable model semantics for logic programs with constraint atoms generalizes a number of previous approaches. Second, we show that our abstract representation of constraint atoms provides a means to characterize dependencies of atoms in a program with constraint atoms, so that some standard characterizations and properties relying on these dependencies in the past for logic programs with ordinary atoms can be extended to logic programs with constraint atoms.

Logic programs with aggregates and description logic programs (dl-programs) are two recent extensions to logic programming. In this paper, we study the relationships between these two classes of logic programs, under the well-founded semantics. The main result is that, under a satisfaction-preserving mapping from dl-atoms to aggregates, the well-founded semantics of dl-programs by Eiter et al., coincides with the well-founded semantics of aggregate programs, defined by Pelov et al. as the least fixpoint of a 3-valued immediate consequence operator under the ultimate approximating aggregate. This result enables an alternative definition of the same well-founded semantics for aggregate programs, in terms of the first principle of unfounded sets. Furthermore, the result can be applied, in a uniform manner, to define the well-founded semantics for dl-programs with aggregates, which agrees with the existing semantics when either dl-atoms or aggregates are absent.

Logic programs, deductive databases, and more generally non-monotonic theories, use various forms of default negation, not F , whose major distinctive feature is that not F is assumed “by default”, i.e., it is assumed in the absence of sufficient evidence to the contrary. The meaning of “sufficient evidence” depends on the specific semantics used. For example, in Reiter’s Closed World Assumption, CWA [32], not A is assumed for atomic A if A is not provable, or, equivalently, if there is a minimal model in which A is false. On the other hand, in Minker’s Generalized Closed World Assumption, GCWA [18, 16], or in McCarthy’s Circumscription, CIRC [17], not A is assumed only if A is false in all minimal models. In Clark’s Predicate Completion semantics for logic programs [7], this form of negation is called negation-as-failure because not A is derivable whenever attempts to prove A finitely fail. The more recent semantics proposed for logic programs and deductive databases, such as the stable semantics [14], well-founded semantics [34], partial stable or stationary semantics [27] and static semantics [30], propose even more sophisticated meanings for default negation, closely related to more general nonmonotonic formalisms such as Default Logic, DL [33], AutoEpistemic Logic, AEL [19], and AutoEpistemic logic of Beliefs, AEB [29]. Under all of these semantics, however, default negation “not ” significantly differs from classical negation “¬”. For example, the formula charged(x) ∧ ¬guilty(x) ⊃ acquitted(x) says that a person charged with a crime should be acquitted if he or she is actually proven to be not guilty. On the other hand, the formula charged(x) ∧ not guilty(x) ⊃ acquitted(x) says that one should be acquitted of any charges by default unless sufficient evidence of that person’s guilt is demonstrated.

An important limitation of traditional logic programming as a knowledge representation tool, in comparison with classical logic, is that logic programming does not allow us to deal directly with incomplete information. In order to overcome this limitation, we extend the class of general logic programs by including classical negation, in addition to negation-as-failure. The semantics of such extended programs is based on the method of stable models. The concept of a disjunctive database can be extended in a similar way. We show that some facts of commonsense knowledge can be represented by logic programs and disjunctive databases more easily when classical negation is available. Computationally, classical negation can be eliminated from extended programs by a simple preprocessor. Extended programs are identical to a special case of default theories in the sense of Reiter.

One of the most appealing characteristics of logic programs is the natural and abundant non-determinism of execution. This non-determinism allows a non-conventional computer to pursue highly parallel computation. Considerable effort has been expended exploiting this potential. The AND/OR Process Model in Conery's dissertation [1] and Concurrent Prolog by Shapiro [2] are two famous pioneering efforts in this area. They are frequently referenced in the literature as bases of improvement and comparison.