Paolo Mancarella

Computing ideal sceptical argumentation

We present two dialectic procedures for the sceptical ideal semantics for argumentation. The first procedure is defined in terms of dispute trees, for abstract argumentation frameworks. The second procedure is defined in dialectical terms, for assumption-based argumentation frameworks. The procedures are adapted from (variants of) corresponding procedures for computing the credulous admissible semantics for assumption-based argumentation, proposed in [P.M. Dung, R.A. Kowalski, F. Toni, Dialectic proof procedures for assumption-based, admissible argumentation, Artificial Intelligence 170 (2006) 114-159]. We prove that the first procedure is sound and complete, and the second procedure is sound in general and complete for a special but natural class of assumption-based argumentation frameworks, that we refer to as p-acyclic. We also prove that in the case of p-acyclic assumption-based argumentation frameworks (a variant of) the procedure of [P.M. Dung, R.A. Kowalski, F. Toni, Dialectic proof procedures for assumption-based, admissible argumentation, Artificial Intelligence 170 (2006) 114-159] for the admissible semantics is complete. Finally, we present a variant of the procedure of [P.M. Dung, R.A. Kowalski, F. Toni, Dialectic proof procedures for assumption-based, admissible argumentation, Artificial Intelligence 170 (2006) 114-159] that is sound for the sceptical grounded semantics.

Modular logic programming

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.

A transformational approach to negation in logic programming

Abstract A transformation technique is introduced which, given the Horn-clause definition of a set of predicates p i , synthesizes the definitions of new predicate p i which can be used, under a suitable refutation procedure, to compute the finite failure set of p i . This technique exhibits some computational advantages, such as the possibility of computing nonground negative goals still preserving the capability of producing answers. The refutation procedure, named SLDN refutation, is proved sound and complete with respect to the completed program.

The CIFF Proof Procedure for Abductive Logic Programming with Constraints

We introduce a new proof procedure for abductive logic programming and present two soundness results. Our procedure extends that of Fung and Kowalski by integrating abductive reasoning with constraint solving and by relaxing the restrictions on allowed inputs for which the procedure can operate correctly. An implementation of our proof procedure is available and has been applied successfully in the context of multiagent systems.

The KGP model of agency for global computing: computational model and prototype implementation

We present the computational counterpart of the KGP (Knowledge, Goals, Plan) declarative model of agency for Global Computing. In this context, a computational entity is seen as an agent developed using Computational Logic tools and techniques. We model a KGP agent by relying upon a collection of capabilities, which are then used to define a collection of transitions, to be used within logically specified, context sensitive control theories, which we call cycle theories. In close relationship to the declarative model, the computational model mirrors the logical architecture by specifying appropriate computational counterparts for the capabilities and using these to give the computational models of the transitions. These computational models and the one specified for the cycle theories are all based on, and are significant extensions of, existing proof procedures for abductive logic programming and logic programming with priorities. We also discuss a prototype implementation of the overall computational model for KGP.

Composition Operators for Logic Theories

Some basic meta-level operators for putting logic theories together are introduced, which relate to set-theoretic union, intersection and difference. Both a transformational and an interpretive characterization of the operators are provided and proved equivalent. The former definition says how to syntactically construct a new theory out of two given theories, the latter provides a meta-level interpretation of the same operators. A declarative — both model-theoretic and fixpoint — semantics of the operators is also provided, allowing one to assign the minimal model of the resulting theory as a function of the models of the argument theories. Some examples from default reasoning, knowledge assimilation, inheritance networks and hypothetical reasoning are presented to demonstrate the expressive power of the operators.

The ciff proof procedure for abductive logic programming with constraints: Theory, implementation and experiments

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.

Computational logic foundations of KGP agents

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 agents 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.

Preferred extensions are partial stable models

Abstract We show that two recently presented proposals for the semantics of normal logic programs, namely partial stable models of Sacca and Zaniolo and preferred extensions of Phan Minh Dung coincide.

A unifying view for logic programming with non-monotonic reasoning

Abstract We provide a simple formulation of a framework where some extensions of logic programming with non-monotonic reasoning are treated uniformly, namely, two kinds of negation and abduction. The resulting semantics is purely model-theoretic, and gives meaning to any noncontradictory abductive logic program. Moreover, it embeds and generalizes some existing semantics which deal with negation and abduction. The framework is equipped with a correct top-down proof procedure.