Deductive Databases Research Articles

{\cal A}{\cal L} -log: Integrating Datalog and Description Logics

We present an integrated system for knowledge representation, called{\cal A}{\cal L} -log, based on description logics and the deductive database language Datalog. {\cal A}{\cal L}-log embodies two subsystems, called structural and relational. The former allows for the definition of structural knowledge about classes of interest (concepts) and membership relation between objects and classes. The latter allows for the definition of relational knowledge about objects described in the structural component. The interaction between the two components is obtained by allowing constraints within Datalog clauses, thus requiring the variables in the clauses to range over the set of instances of a specified concept. We propose a method for query answering in {\cal A}{\cal L}-log based on constrained resolution, where the usual deduction procedure defined for Datalog is integrated with a method for reasoning on the structural knowledge.

O!-LOLA – Extending the Deductive Database System LOLA by Object-Oriented Logic Programming

O!-LOLA – Extending the Deductive Database System LOLA by Object-Oriented Logic Programming

Reasoning About Data Provided By Federated Deductive Databases

This paper focuses on the problem of reasoning with information provided by a group of databases which share a common set of rules (deductive rules, integrity constraints). Each database is assumed to be consistent with the rules, but federating them may lead to contradictions. This paper describes a logic of beliefs, based on KD logic, for reasoning with contradictory information provided by several databases. It also presents a theorem prover, associated with this logic. This prover, described as a meta-interpreter of PROLOG allows us to derive formulas of the form: given the databases and the rules, assuming an order of relative reliability between the databases, is a given formula deducible? or, what are the individuals which satisfy a given formula? When the set of rules is not recursive, we prove the correctness of this theorem-prover.

Uncertain deductive databases: A hybrid approach

Uncertainty in deductive databases and logic programming has been modeled using a variety of (numeric and non-numeric) formalisms in the past, including probabilistic, possibilistic, and fuzzy set-theoretic approaches, and many valued logic programming. In this paper, we consider a hybrid approach to the modeling of uncertainty in deductive databases. Our model, called deductive IST (DIST) is based on an extension of the Information Source Tracking (IST) model, recently proposed for relational databases. The DIST model permits uncertainty to be modeled and manipulated in essentially qualitative terms with an option to convert qualitative expressions of uncertainty into numeric form (e.g., probabilities). An uncertain deductive database is modeled as a Horn clause program in the DIST framework, where each fact and rule is annotated with an expression indicating the “sources” contributing to this information and their nature of contribution. (1) We show that positive DIST programs enjoy the least model/least fixpoint semantics analogous to classical logic programs. (2) We show that top-down (e.g., SLD-resolution) and bottom-up (e.g., magic sets rewriting followed by semi-naive evaluation) query processing strategies developed for datalog can be easily extended to DIST programs. (3) Results and techniques for handling negation as failure in classical logic programming can be easily extended to DIST. As an illustration of this, we show how stratified negation can be so extended. We next study the problem of query optimization in such databases and establish the following results. (4) We formulate query containment in qualitative as well as quantitative terms. Intuitively, our qualitative sense of containment would say a query Q 1 is contained in a query Q 2 provided for every input database D, for every tuple t, t ϵ Q 2( D) holds in every “situation” in which t ϵ Q 1( D) is true. The quantitative notion of containment would say Q 1 is contained in Q 2 provided on every input, the certainty associated with any tuple computed by Q 1 is no more than the certainty associated with the same tuple by Q 2 on the given input. We also prove that qualitative and quantitative notions of containment (both absolute and uniform versions) coincide. (5) We establish necessary and sufficient conditions for the qualitative containment of conjunctive queries. (6) We extend the well-known chase technique to develop a test for uniform containment and equivalence of positive DIST programs. (7) Finally, we prove that the complexity of testing containment of conjunctive DIST queries remains the same as in the classical case when number of information sources is regarded as a constant (so, it's NP-complete in the size of the queries). We also show that testing containment of conjunctive queries is co-NP-complete in the number of information sources.

Reasoning with minimal models: efficient algorithms and applications

Reasoning with minimal models is at the heart of many knowledge-representation systems. Yet it turns out that this task is formidable, even when very simple theories are considered. In this paper, we introduce the elimination algorithm, which performs, in linear time, minimal model finding and minimal model checking for a significant subclass of positive CNF theories which we call positive head-cycle-free (HCF) theories. We also prove that the task of minimal entailment is easier for positive HCF theories than it is for the class of all positive CNF theories. Finally, we show how variations of the elimination algorithm can be applied to allow queries posed on disjunctive deductive databases and disjunctive default theories to be answered in an efficient way.

Intuitionistic deductive databases and the polynomial time hierarchy

Deductive databases are poor at tasks such as planning and design, where one must explore the consequences of hypothetical actions and possibilities. To address this limitation, we have developed a deductive database language in which a user can create hypotheses and draw inferences from them. In earlier work, we established initial results on the complexity and expressibility of this language. In this paper, we establish more comprehensive results by exploring the interaction of negation-as-failure with a natural syntactic restriction called linearity. The main result is a tight connection between intuitionistic logic, database queries, and the polynomial time hierarchy. A tight connection with second-order logic follows as a corollary. First, we show that rulebases in our language fit neatly into a well-established logical framework— intuitionistic logic. Second, we show that linearity reduces their data complexity from PSPACE to NP. Third, we show that negation-as-failure increase their complexity from NP to some level in the polynomial time hierarchy (PHIER). Specifically, linear rulebases with k strata are data complete for ∑ k P, the kth level in the hierarchy. Fourth, we show that linear rulebases express exactly the generic database queries in PHIER. Finally, we characterize the generic queries in ∑ k P in terms of rulebases with k strata. Unlike many other expressibility results in the literature, these results do not depend on the artificial assumption that the data domain is linearly ordered. We thus establish a strong link between two well-established, but previously unrelated areas: intuitionistic logic and the polynomial time hierarchy.

Expanding a distributed deductive database with mobile computing

Mobile computing is a component that will be included in many future computing environments. This paper presents a scheme that will allow the addition of a mobile component to an existing distributed deductive database. This scheme allows for the following features: 1) data replication on the mobile unit, 2) transaction logging to log changes both in the mobile user's database and in the network's database, 3) concurrency control to prevent both copies from updating the same record, and 4) reconnection procedures to update both copies upon reconnection. To facilitate data replication and reconnection updates, we have established ‘Proxy Nodes’ in the network database to keep track of data of interest to the mobile user.

FREDDI: A fuzzy RElational deductive database interface

This paper shows an architecture for Deductive Fuzzy RDBMS which integrates two approaches of fuzzy databases: the relational and the logical ones. It uses the first one to represent and manipulate imprecise information and the second one to obtain intensional information. Besides, it shows how it is possible to use the resources offered by a conventional RDBMS together with a deduction module to build a complete DFRDBMS capable of handling queries of imprecise and/or deductive nature. This task is carried out using an extension of SQL language.

A logical semantics for hypothetical rulebases with deletion

This paper addresses a limitation of most deductive database systems: they cannot reason hypothetically. Although they reason effectively about the world as it is, they are poor at tasks such as planning and design, where one must explore the consequences of hypothetical actions and possibilities. To address this limitation, we have developed a logic-programming language in which users can create hypotheses and draw inferences from them. Most previous work in this area has focused on the hypothetical insertion of facts into a database since insertion is accounted for by a well-established logic: intuitionistic logic. In contrast, our language includes hypothetical deletion as well as insertion. In earlier work, we established the data complexity and expressibility of this language. In this paper, we develop its logical semantics, and take a closer look at its expressibility. The paper makes three main contributions. First, we show that hypothetical queries lead naturally to a new notion of expressibility. In this new light, we show that classical logic is poor at hypothetical reasoning since it cannot express some simple hypothetical queries. Second, we develop a logical semantics for hypothetical insertions and deletions, including a proof theory, model theory, and fixpoint theory. We also give numerous examples showing the utility of the logic and the subtle effect that deletion has on its expressive power. Finally, we augment the logic with negation-as-failure so that nonmonotonic queries can be expressed. We then develop the proof theory and model theory for the logic with negation. The proof theory is inspired by the stratified semantics of Apt, Blair, and Walker, and the model theory is inspired by the perfect model semantics of Przymusinski.

FREDDI: A fuzzy RElational deductive database interface

This paper shows an architecture for Deductive Fuzzy RDBMS which integrates two approaches of fuzzy databases: the relational and the logical ones. It uses the first one to represent and manipulate imprecise information and the second one to obtain intensional information. Besides, it shows how it is possible to use the resources offered by a conventional RDBMS together with a deduction module to build a complete DFRDBMS capable of handling queries of imprecise and/or deductive nature. This task is carried out using an extension of SQL language. © John Wiley & Sons, Inc.

Heuristic and randomized optimization for the join ordering problem

Recent developments in database technology, such as deductive database systems, have given rise to the demand for new, cost-effective optimization techniques for join expressions. In this paper many different algorithms that compute approximate solutions for optimizing join orders are studied since traditional dynamic programming techniques are not appropriate for complex problems. Two possible solution spaces, the space of left-deep and bushy processing trees, are evaluated from a statistical point of view. The result is that the common limitation to left-deep processing trees is only advisable for certain join graph types. Basically, optimizers from three classes are analysed: heuristic, randomized and genetic algorithms. Each one is extensively scrutinized with respect to its working principle and its fitness for the desired application. It turns out that randomized and genetic algorithms are well suited for optimizing join expressions. They generate solutions of high quality within a reasonable running time. The benefits of heuristic optimizers, namely the short running time, are often outweighed by merely moderate optimization performance.

A reasoning mechanism for deductive object-oriented databases

Based on the approach implementing a deductive object-oriented database system through the underlying relational database, this paper presents an object reasoning language O-Datalog, which is the extension of Datalog in form and can deal with object-oriented data. For any O-Datalog program, an equivalent Datalog program can be built to help evaluate the original program. This paper focuses on the syntax, semantics and evaluation of O-Datalog.

A logic-based integration of active and deductive databases

A logic-based approach to the specification of active database functionality is presented which not only endows active databases with a well-defined and well-understood formal semantics, but also tightly integrates them with deductive databases. The problem of endowing deductive databases with rule-based active behaviour has been addressed in different ways. Typical approaches include accounting for active behaviour by extending the operational semantics of deductive databases, or, conversely, accounting for deductive capabilities by constraining the operational semantics of active databases. The main contribution of the paper is an alternative approach in which a class of active databases is defined whose operational semantics is naturally integrated with the operational semantics of deductive databases without either of them strictly subsuming the other. The approach is demonstrated via the formalization of the syntax and semantics of an active-rule language that can be smoothly incorporated into existing deductive databases, due to the fact that the standard formalization of deductive databases is reused, rather than altered or extended. One distinctive feature of the paper is its use of ahistory, as defined in the Kowalski-Sergot event-calculus, to define event occurrences, database states and actions on these. This has proved to be a suitable foundation for a comprehensive logical account of the concept set underpinning active databases. The paper thus contributes a logical perspective to the ongoing task of developing a formal theory of active databases.

Reasoning with Uncertainty in Deductive Databases and Logic Programs

Of all scientific investigations into reasoning with uncertainty and chance, probability theory is perhaps the best understood paradigm. Nevertheless, all studies conducted thus far on the semantics of quantitative logic programming have been restricted to non-probabilistic semantical characterizations. In this paper, we survey the major features and summarize the major results of the various frameworks that we have developed to rectify this situation. In the first part of this paper, we outline a deductive database framework which is expressive enough to represent such probabilistic relationships as conditional probabilities, Bayesian updates, probability propagation and mutual exclusion. We propose a fixpoint theory and a probabilistic model theory, and characterize their inter-relationships. As the aforementioned language is monotonic in nature, we discuss in the second half of this paper three approaches of supporting non-monotonic probabilistic reasoning. In the first approach, we use a non-monotonic negation operator. In the second, we use the Dempster-Shafer rule of combination. Finally, we discuss how empirical probabilities can be supported in monadic deductive databases.

Incremental algorithms for optimizing model computation based on partial instantiation

It has been shown that mixed integer programming methods can effectively support minimal model, stable model and well-founded model semantics for ground deductive databases. Recently, a novel approach called partial instantiation has been developed which, when integrated with mixed integer programming methods, can handle non-ground logic programs. The goal of this paper is to explore how this integrated framework based on partial instantiation can be optimized. In particular, we develop an incremental algorithm that minimizes repetitive computations. We also develop several optimization techniques to further enhance the efficiency of our incremental algorithm. Experimental results indicate that our algorithm and optimization techniques can bring about very significant improvement in run-time performance.

Vertical fragmentation and allocation in distributed deductive database systems

Although approaches for vertical fragmentation and data allocation have been proposed, algorithms for vertical fragmentation and allocation of data and rules in distributed deductive database systems (DDDBSs) are lacking. In this paper, we present different approaches for vertical fragmentation of relations that are referenced by rules and an allocation strategy for rules and fragments in a DDDBS. The potential advantages of the proposed fragmentation and allocation scheme include maximal locality of query evaluation and minimization of communication cost in a distributed system, in addition to the desirable properties of (vertical) fragmentation and rule allocation as discussed in the literature. We also formulate the mathematical interpretation of the proposed vertical fragmentation and allocation algorithms.

Reusing and Modifying Rulebases by Predicate Substitution

We propose a method for reusing and modifying a deductive database. The need for such techniques occurs when new rulebased applications differ only slightly from existing ones or when an application is to be incrementally updated. Such techniques are particularly important when reprogramming is expensive or unreliable. In order to facilitate reuse, we extend deductive database systems by the concept ofpredicate substitution. In this way, during query evaluation, not only variables, but also predicates can be substituted. We provide a proof theory and a model theory for this language, including a fixpoint semantics. In addition, we show that substitution increases the expressive power of Datalog: not only does its data complexity increase from PTIME to EXPTIME, but substitution also allows large sets of Datalog rules to be succinctly expressed. In fact, finite rulebases with substitution can express infinite rulebases without substitution

Monotonic Aggregation in Deductive Databases

We propose a semantics for aggregates in deductive databases based on a notion of minimality. Unlike some previous approaches, we form a minimal model of a program component including aggregate operators, rather than insisting that the aggregate apply to atoms that have been fully determined or that aggregate functions are rewritten in terms of negation. In order to guarantee the existence of such a minimal model we need to insist that the domains over which we are aggregating are complete lattices and that the program is in a sense mono- tonic. Our approach generalizes previous approaches based on the well-founded semantics and various forms of stratification. We are also able to handle a large variety of monotonic (or pseudo-monotonic) aggregate functions.

Implementation of a deductive database system using SQLBase

Deductive databases intellectualize relational databases by providing complex inference ability and they are competitive with current commercial relational databases. The deductive system presented in this paper is a unified logic/database system where programs may be expressed declaratively, in a form close to first-order logic, and at the same time efficiently access very large data bases. The implementation is based on a logic-based language compilation. A Prolog-like program is translated into Warren Abstract Machine (WAM) instructions by a compiler, and the resulting WAM code is executed by an emulator. The inference engine and the relational database are tightly coupled, i.e. external records are retrieved from the underlying database and unified with Prolog-like terms as and when required. The tight coupling of a logic-based language and a relational DBMS achieved a satisfactory performance.

Implementation of locking schemes in extended dependency graphs

Concurrency control in deductive databases is an important issue which deserves much attention. In this paper we examine implementation of locking schemes. We adopt a model based on dependency graphs extended with compatibility trees, and describe features related to implementation of locking schemes in this model. Algorithms for read and write locking schemes are provided, and are illustrated by several examples. Although these algorithms are simple, they exemplify what are the unique problems of concurrency control that may be encountered in deductive databases, and how to deal with these problems.