Paola Mello

AI*IA 99: Advances in Artificial Intelligence

Logical approaches to nonmonotonic reasoning have been developed within di erent technical settings thus making it di cult to establish correspondences among them and to identify common under lying principles In this paper we argue that the most well known non monotonic reasoning formalisms are actually characterized by two closure assumptions a minimal knowledge assumption and an autoepistemic as sumption We justify this thesis by introducing generalized default logic GDL obtained through a simple and natural generalization of Reit er s default logic which fully captures both closure assumptions We then analyze the relationship between GDL and nonmonotonic modal logics in particular Moore s autoepistemic logic and Lifschitz s logic of minimal knowledge and negation as failure showing the existence of a full correspondence between these modal formalisms and GDL Such a correspondence gives us a uni ed reading of nonmonotonic reasoning for malisms in terms of the above two assumptions in particular it clari es the relationship between default and autoepistemic logic

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.

Exploiting Symbolic Learning in Visual Inspection

The paper describes the use of data analysis techniques in the computer-vision inspection of industrial workpieces. Computer-vision inspection aims at accomplishing quality verification of fabricated parts by means of automated visual procedures. Gathering the visual information into models proves a critical task, especially when subjective judgement is involved in quality verification. In this work, intelligent data analysis techniques based on symbolic learning by examples have been explored in order to automatically devise and parametrize effective quantitative models. The paper reports and discusses the experimental results achieved in an industrial application.

Distributed logic objects

This paper presents a language based on the logic programming paradigm that supports objects, messages and inheritance. The object-oriented extension is fairly simple: objects are clusters of processes, objects state is represented by logical variables, message-passing communication between objects is performed via multi-head clauses, and inheritance is mapped into clause union. The language implementation is obtained by translating logic objects into a concurrent logic language based on multi-head clauses, taking advantage of its distributed implementation on a massively parallel architecture. The runtime support realizes some interesting features such as intensional messages and the transparency of object allocation, object migration and parallelism.

Extending constraint logic programming for temporal reasoning

In recent years, several constraint‐based temporal reasoning frameworks have been proposed. They consider temporal points or intervals as domain elements linked by temporal constraints. Temporal reasoning in these systems is based on constraint propagation. In this paper, we argue that a language based on constraint propagation can be a suitable tool for expressing and reasoning about temporal problems. We concentrate on Constraint Logic Programming (CLP) which is a powerful programming paradigm combining the advantages of Logic Programming and the efficiency of constraint solving. However, CLP presents some limitations in dealing with temporal reasoning. First, it uses an “arc consistency” propagation algorithm which is embedded in the inference engine, cannot be changed by the user, and is too weak in many temporal frameworks. Second, CLP is not able to deal with qualitative temporal constraints. We present a general meta CLP architecture which maintains the advantages of CLP, but overcomes these two main limitations. Each architectural level is a finite domain constraint solver(CLP(FD)) that reasons about constraints of the underlying level. Based on this conceptual architecture, we extend the CLP(FD)language and we specialize the extension proposed on Vilain and Kautz’sPoint Algebra, on Allen’s Interval Algebra and on the STP framework by Dechter, Meiri and Pearl. In particular, we show that we can cope effectively with disjunctive constraints even in an interval‐based framework.

Combining Solvers in a Meta Constraint Logic Programming Architecture

We present a general technique for the combination and the integration of different Constraint Logic Programming (CLP) solvers. The main idea behind the work concerns the possibility of building meta CLP architectures by adding CLP solvers in a natural and effective manner. In the meta architecture, levels are constraint solvers each reasoning on constraints of the underlying system. The architecture presented starts from a meta Constraint Logic Programming general scheme. A distinguishing feature of the architectural scheme concerns its operational semantics which can be seen as a general combination method for data and control of two constraint solvers. A set of linking rules define how systems exchange data, while a set of transition rules define how systems combine their control flow. We propose a specialization of a meta CLP architecture on finite domains. The specialization concerns the possibility of combining qualitative and quantitative reasoning in a CLP framework. This combination can be useful, for example, in the field of temporal reasoning.

Distributed Logic Objects: A Fragment of Rewriting Logic and its Implementation

Abstract This paper presents a logic language (called Distributed Logic Objects , DLO for short) that supports objects, messages and inheritance. The operational semantics of the language is given in terms of rewriting rules acting upon the (possibly distributed) state of the system. In this sense, the logic underlying the language is Rewriting Logic. In the paper we discuss the implementation of this language on distributed memory MIMD architectures, and we describe the advantages achieved in terms of flexibility, scalability and load balancing. In more detail, the implementation is obtained by translating logic objects into a concurrent logic language based on multi-head clauses, taking advantage from its distributed implementation on a massively parallel architecture. In the underlying implementation, objects are clusters of processes, objects state is represented by logical variables, message-passing communication between objects is performed via multi-head clauses, and inheritance is mapped into clause union. Some interesting features such as transparent object migration and intensional messages are easily achieved thanks to the underlying support. In the paper, we also sketch a (direct) distributed implementation supporting the indexing of clauses for single-named methods.

Optimizing modular logic languages

Permission to make digital/hard copy of part or all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its date appear, and notice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee.

Reasoning on constraints in CLP(FD)

Abstract Constraint Logic Programming solvers on finite domains (CLP(FD) solvers) use constraints to prune those combinations of assignments which cannot appear in any consistent solution. There are applications, such as temporal reasoning or scheduling, requiring some form of qualitative reasoning where constraints can be changed (restricted) during the computation or even chosen when disjunction occurs. We embed in a (CLP(FD) solver the concept of constraints as first class objects. In the extended language, variables range over finite domains of objects (e.g., integers) and relation variables range over finite domains of relation symbols. We define operations and constraints on the two sorts of variables and one constraint linking the two. We first present the extension as a general framework, then we propose two specializations on finite domains of integers and of sets. Programming examples are given, showing the advantages of the extension proposed from both a knowledge representation and an operational viewpoint.

An abstract interpretation framework for optimizing dynamic modular logic languages

The aim of this paper is to show how to improve the implementation of dynamic modular languages by enhancing the efficiency of the search technique adopted and by avoiding the search when possible.