Bert Van Nuffelen

Database Repair by Signed Formulae

We introduce a simple and practically efficient method for repairing inconsistent databases. The idea is to properly represent the underlying problem, and then use off-the-shelf applications for efficiently computing the corresponding solutions.

A-system: Declarative Programming with Abduction

The A-system [4] is a new system for performing abductive reasoning within the framework of Abductive Logic Programming (ALP). The principles behind the system are founded by work on two earlier systems ACLP [2],[3] and SLDNFA(C) [1],[6]. The basic inference mechanism of the system combines abductive logicp rogramming and constraint logicp rogramming. In its computation it reduces the high level specification of the problem and goal at hand to a lower level constraint store. This constraint store is managed by an efficient constraint solver returning information to the abductive reduction process in order to help this in its search for a solution.

Computational methods for database repair by signed formulae

We introduce a simple and practical method for repairing inconsistent databases. Given a possibly inconsistent database, the idea is to properly represent the underlying problem, i.e., to describe the possible ways of restoring its consistency. We do so by what we call signed formulae, and show how the ‘signed theory’ that is obtained can be used by a variety of off-the-shelf computational models in order to compute the corresponding solutions, i.e., consistent repairs of the database.

On the local closed-world assumption of data-sources

The Closed-World Assumption (CWA) on a database expresses that an atom not in the database is false. The CWA is only applicable in domains where the database has complete knowledge. In many cases, for example in the context of distributed databases, a data source has only complete knowledge about part of the domain of discourse. In this paper, we introduce an expressive and intuitively appealing method of representing a local closed-world assumption (LCWA) of autonomous data-sources. This approach distinguishes between the data that is conveyed by a data-source and the meta-knowledge about the area in which these data is complete. The data is stored in a relational database that can be queried in the standard way, whereas the meta-knowledge about its completeness is expressed by a first order theory that can be processed by an independent reasoning system (for example a mediator). We consider different ways of representing our approach, relate it to other methods of representing local closed-word assumptions of data-sources, and show some useful properties of our framework which facilitate its application in real-life systems.

Data Integration Using ID -Logic

ID-Logic is a knowledge representation language that extends first-order logic with non-monotone inductive definitions. This paper introduces an ID-Logic based framework for database schema integration. It allows us to to uniformly represent and reason with independent source databases that contain information about a common domain, but may have different schemas. The ID-Logic theories that are obtained are called mediator-based systems. We show that these theories properly capture the common methods for data integration (i.e., global-as view and local-as-view with either exact or partial definitions), and apply on them a robust abductive inference technique for query answering.

Coherent Composition of Distributed Knowledge-Bases Through Abduction

We introduce an abductive method for coherent composition of distributed data. Our approach is based on an abductive inference procedure that is applied on a meta-theory that relates different, possibly inconsistent, input databases. Repairs of the integrated data are computed, resultingin a consistent output database that satisfies the meta-theory. Our framework is based on the A-system, which is an abductive system that implements SLDNFA-resolution. The outcome is a robust application that, to the best of our knowledge, is more expressive (thus more general) than any other existing application for coherent data integration.

On the Transformation of Object-Oriented Conceptual Models to Logical Theories

This paper describes a semi-automatic transformation from object-oriented conceptual models to logical theories. By associating a logical theory with a conceptual model, we are able to combine the best of both worlds. On one hand, the object-oriented software development paradigm is recognized to be well-suited to build maintainable and communicable conceptual models. On the other hand, the logical programming paradigm offers very powerful and semantically founded concepts to represent knowledge and the use of logical inference systems makes it possible to prototype solutions to computational tasks. Since our method makes this mapping from conceptual models to logical theories traceable, dealing with the evolution of the problem domain and requirements becomes more manageable. Moreover a path is offered towards building prototypes for object-oriented conceptual models.

An ID-logic formalization of the composition of autonomous databases

We introduce a declarative approach for a coherent composition of autonomous databases. For this we use ID-logic, a formalism that extends classical logic with inductive definitions. We consider ID-logic theories that express, at the same time, the two basic challenges in database composition problems: relating different schemas of the local databases to one global schema (schema integration) and amalgamating the distributed and possibly contradictory data to one consistent database (data integration). We show that our framework supports different methods for schema integration (as well as their combinations) and that it provides a straightforward way of dealing with inconsistent data. Moreover, this framework facilitates the implementation of database repair and consistent query answering by means of a variety of reasoning systems.

On the Transformation of Object Oriented Conceptual Models to Logical Theories: From EROOS to ID-Logic

In [1], the authors present a semi-automatic transformation from object-oriented conceptual models to logical theories. By associating a logical theory with a conceptual model, the best of both worlds is combined. On one hand, the object-oriented software development paradigm is recognized to be well-suited to build maintainable and communicable conceptual models. On the other hand, the logical programming paradigm offers semantically founded concepts to represent knowledge and the powerful logical inference systems make it possible to prototype solutions to computational tasks.