Abstract This paper shows how argumentation logic (AL) can be further extended to cover more fully paraconsistent forms of logical reasoning. The extension is based on the notion of non-acceptable, self-defeating arguments as a generalization of the Reductio ad Absurdum principle. In this case, a self-defeating argument is either in conflict with itself or with an argument that is needed for its defense against one of its counter-arguments. In the proposed extended AL, such self-defeating arguments are recognized as arguments that do not need to be explicitly defended against. Hence attacks on other arguments by self-defeating arguments can be ignored, thus extending the possibility of the attacked arguments to be acceptable.

We propose a novel logic-based argumentation framework, called Argumentation Logic (AL), built upon a restriction of classical Propositional Logic (PL) as its underlying logic. This allows us to control the application of Reduction ad Absurdum (RA). In the case of classically consistent theories, AL and PL are equivalent, and RA is recovered through a notion of (non-)acceptability of arguments. In the case of classically inconsistent theories, AL is an extension of PL that does not trivialize, enjoying good logic-based argumentation and general logical properties.

Arguments need to be judged against other arguments. The decision to accept or reject an argument is generally a global decision that involves examining the same question for other arguments that oppose or can defend the argument in question. This article presents the acceptability semantics for abstract argumentation that through a recursive definition gives a global assignment of the acceptable and non-acceptable subsets of arguments. This semantics stems from the aim to formalize directly the generally accepted intuition that: ‘An argument can be accepted if and only if all its challenging arguments can be rejected.’ The acceptability semantics tightly integrates the notion of defending against a challenging argument by counter-attacking it with the notion of self-defeating (or self-rejecting) arguments that (help to) bring about their own non-acceptability. The proposal is motivated by earlier studies of the semantics of Logic Programming (LP) in terms of argumentation, where the basic well founded and stable model semantics of LP can be uniformly captured using a recursively defined argumentation semantics for Negation as Failure and where these standard semantics of LP can be further extended through argumentation.

We give some design guidelines for argumentation systems. These guidelines are meant to indicate essential features of argumentation when used to support “practical reasoning”. We express the guidelines in terms of postulates. We use a notion of redundancy to provide a formal counterpart of these postulates. We study the satisfaction of these postulates in two existing argumentation frameworks: assumption-based argumentation and argumentation in classical logic.

Abstract We present the CIFF proof procedure for abductive logic programming with constraints, and we prove its correctness. CIFF is an extension of the IFF proof procedure for abductive logic programming, relaxing the original restrictions over variable quantification (allowedness conditions) and incorporating a constraint solver to deal with numerical constraints as in constraint logic programming. Finally, we describe the CIFF system, comparing it with state-of-the-art abductive systems and answer set solvers and showing how to use it to program some applications.

This paper presents the computational logic foundations of a model of agency called the KGP (Knowledge, Goals and Plan model. This model allows the specification of heterogeneous agents that can interact with each other, and can exhibit both proactive and reactive behaviour allowing them to function in dynamic environments by adjusting their goals and plans when changes happen in such environments. KGP provides a highly modular agent architecture that integrates a collection of reasoning and physical capabilities, synthesised within transitions that update the agent's state in response to reasoning, sensing and acting. Transitions are orchestrated by cycle theories that specify the order in which transitions are executed while taking into account the dynamic context and agent preferences, as well as selection operators for providing inputs to transitions.

We propose a formalism and a programming environment in which sophisticated spatio-temporal reasoning can be performed, while keeping the capabilities of manipulating and presenting large amounts of geographical data, typical of commercial Geographical Information Systems (GISs). The spatio-temporal knowledge representation language, named MuTACLP+, is based on constraint logic programming and is integrated via a middleware of commands and translation features with a commercial GIS. The paper presents the language, the architecture of the environment, and a few examples of its use in the field of event planning.

We study action rule-based systems with two forms of negation, namely classical negation and "negation as failure to find a course of action". We show, by means of several examples, that adding negation as failure to such systems increases their expressiveness in the sense that real-life problems can be represented in a natural and simple way. Then we address the problem of providing a formal declarative semantics to these extended systems by adopting an argumentation-based approach which has been shown to be a simple unifying framework for understanding the declarative semantics of various nonmonotonic formalisms. In this way, we naturally define the grounded (well-founded), stable and preferred semantics for production systems with negation as failure. Next, we characterize the class of stratified production systems, which enjoy the properties that the above-mentioned semantics coincide and that negation as failure to find a course of action can be computed by a simple bottom-up operator. Stratified production systems can be implemented on top of conventional production systems in two ways. The first way corresponds to the understanding of stratification as a form of priority assignment between rules. We show that this implementation, though sound, is not complete in the general case. Hence, we propose a second implementation by means of an algorithm which transforms a finite stratified production system into a classical one. This is a sound and complete implementation, though it is computationally hard.

We present a knowledge representation framework where a collection of logic programs can be combined together by means of meta-level program composition operations. Each object-level program is composed of a collection of extended clauses, equipped with a time interval representing the time period in which they hold. The interaction between program composition operations and time yields a powerful knowledge representation language in which many applications can be naturally developed. The language is given a meta-level semantics which also provides an executable specification. Moreover, we define an abstract semantics by extending the immediate consequence operator from a single logic program to compositions of logic programs and taking into account time intervals. The operational, meta-level semantics is proven sound and complete with respect to the abstract bottom-up semantics. The approach is further extended in order to cope with the problem of reasoning over joined intervals of time. Three applications in the field of business regulations are shown.

Modularity is a key issue in the design of modern programming languages. When designing modular features for declarative languages in general, and for logic programming languages in particular, the challenge lies in avoiding the superimposition of a complex syntactic and semantic structure over the simple structure of the basic language. The modular framework defined here for logic programming consists of a small number of operations over modules which are (meta-) logically defined and semantically justified in terms of the basic logic programming semantics. The operations enjoy a number of algebraic properties, thus yielding an algebra of modules. Despite its simplicity, the suite of operations is shown capable of capturing the core features of modularization: information hiding, import/export relationships, and construction of module hierarchies. A metalevel implementation and a compilation-oriented implementation of the operations are provided and proved sound with respect to the semantics. The compilation-oriented implementation is based on manipulation of name spaces and provides the basis for an efficient implementation.