Deductive Databases Research Articles

Identifying amino acid residues in medium resolution critical point graphs using instance based query generation.

Instance Based Query Generation is defined and applied to the problem of recognising amino acid residues in medium resolution critical point graphs. The technique is an amalgamation of Relational Instance Based Learning and Frequent Query Discovery in First Order Logic. Instances are automatically constructed from a deductive database and first order association rules are derived from the instances. The initial investigations presented here indicate that the technique is able to discriminate some of the larger amino acid types as well as discriminating the protein from background solvent. Identification of the smaller amino acids remains difficult and requires further work.

Declarative PTIME queries for relational databases using quantifier elimination

In this paper, we consider the problem of expressing and computing queries on relational deductive databases in a purely declarative query language, called SHQL (Semi-Horn Query Language). Assuming the relational databases in question are ordered, we show that all SHQL queries are computable in PTIME (polynomial time) and the whole class of PTIME queries is expressible in SHQL. Although similar results have been proven for fixpoint languages and extensions to datalog, the claim is that SHQL has the advantage of being purely declarative, where the negation operator is interpreted as classical negation, mixed quantifiers may be used and a query is simply a restricted first-order theory not limited by the rule-based syntactic restrictions associated with logic programs in general. We describe the PTIME algorithm used to compute queries in SHQL which is based in part on quantifier elimination techniques and also consider extending the method to incomplete relational databases using intuitions related to circumscription techniques.

Inductive Logic Programming: Issues, results and the challenge of Learning Language in Logic

Inductive Logic Programming (ILP) is the area of AI which deals with the induction of hypothesised predicate definitions from examples and background knowledge. Logic programs are used as a single representation for examples, background knowledge and hypotheses. ILP is differentiated from most other forms of Machine Learning (ML) both by its use of an expressive representation language and its ability to make use of logically encoded background knowledge. This has allowed successful applications of ILP in areas such as molecular biology and natural language which both have rich sources of background knowledge and both benefit from the use of an expressive concept representation languages. For instance, the ILP system Progol has recently been used to generate comprehensible descriptions of the 23 most populated fold classes of proteins, where no such descriptions had previously been formulated manually. In the natural language area ILP has not only been shown to have higher accuracies than various other ML approaches in learning the past tense of English but also shown to be capable of learning accurate grammars which translate sentences into deductive database queries. The area of Learning Language in Logic (LLL) is producing a number of challenges to existing ILP theory and implementations. In particular, language applications of ILP require revision and extension of a hierarchically defined set of predicates in which the examples are typically only provided for predicates at the top of the hierarchy. New predicates often need to be invented, and complex recursion is usually involved. Advances in ILP theory and implementation related to the challenges of LLL are already producing beneficial advances in other sequence-oriented applications of ILP. In addition LLL is starting to develop its own character as a sub-discipline of AI involving the confluence of computational linguistics, machine learning and logic programming.

A study of relevance for learning in deductive databases

This paper is a study of the problem of relevance in inductive concept learning. It gives definitions of irrelevant literals and irrelevant examples and presents efficient algorithms that enable their elimination. The proposed approach is directly applicable in propositional learning and in relation learning tasks that can be solved using a LINUS transformation approach. A simple inductive logic programming (ILP) problem is used to illustrate the approach to irrelevant literal and example elimination. Results of utility studies show the usefulness of literal reduction applied in LINUS and in the search of refinement graphs.

On cyclic covers and perfect models

Cyclic covers represent the complex relationships between predicates lying within, and outside of, a perfect model of an indefinite stratified deductive database, and are shown to facilitate the solution to a variety of problems under the perfect model semantics. Cyclic covers are shown to characterise view updates, and this yields a top–down method for solving the view insertion problem via the computation of partially cyclic covers and a simple closure operation. Weakly cyclic covers and cyclic trees are shown to yield methods of partially evaluating (i.e., pre-processing) the intensional database to facilitate query compilation, the identification of redundant rules, the removal of recursion and the removal of positive or negative intensional sub-goals. Such pre-processing is immune to future changes in the extensional database. The notion of a conjunctive answer to a database query is introduced. Such answers do not suffer from the problems of redundancy as seen with (the more commonly studied) “disjunctive” answers. In addition, conjunctive answers yield more information about their query than do their disjunctive counterparts, and in particular the set of disjunctive answers can be computed from the set of conjunctive answers, whereas the converse does not hold. Cyclic covers are shown to characterise conjunctive answers, thus yielding a top–down method of computing such answers. The problem of computing conjunctive answers is shown to be a special case of the view update problem.

Linear logic for deductive databases

This paper deals with deductive databases in linear logic. The semantics of queries, views, constraints, and (view) updates are defineddeclaratively in linear logic. In constrast to classical logic, we can formalise non-shared view, transition constraints, and (view) updates easily. Various proof search strategies are presented along with an algorithm for query evaluation from a bottom-up direction. An additional advantage is that the associated meaning of a given relation can be defined in terms of the validity of a legal update in a given relation. We also defined formally the update principles and showed the correctness of the update translation algorithms. In this approach, we provide virtual view updates along with real view updates, and view DELETIONs are special cases of view REPLACEMENTs. This permits three transactional view update operations (INSERTION, DELETION, REPLACEMENT) in comparison to only (INSERTION, DELETION) in most existing systems.

Belief reasoning in MLS deductive databases

It is envisaged that the application of the multilevel security (MLS) scheme will enhance flexibility and effectiveness of authorization policies in shared enterprise databases and will replace cumbersome authorization enforcement practices through complicated view definitions on a per user basis. However, as advances in this area are being made and ideas crystallized, the concomitant weaknesses of the MLS databases are also surfacing. We insist that the critical problem with the current model is that the belief at a higher security level is cluttered with irrelevant or inconsistent data as no mechanism for attenuation is supported. Critics also argue that it is imperative for MLS database users to theorize about the belief of others, perhaps at different security levels, an apparatus that is currently missing and the absence of which is seriously felt. The impetus for our current research is this need to provide an adequate framework for belief reasoning in MLS databases. We demonstrate that a prudent application of the concept of inheritance in a deductive database setting will help capture the notion of declarative belief and belief reasoning in MLS databases in an elegant way. To this end, we develop a function to compute belief in multiple modes which can be used to reason about the beliefs of other users. We strive to develop a poised and practical logical characterization of MLS databases for the first time based on the inherently difficult concept of non-monotonic inheritance. We present an extension of the acclaimed Datalog language, called the MultiLog, and show that Datalog is a special case of our language. We also suggest an implementation scheme for MultiLog as a front-end for CORAL.

Three types of redundancy in integrity checking: An optimal solution

Known methods for checking integrity constraints in deductive databases do not eliminate all aspects of redundancy in integrity checking. By making the redundancy aspects of integrity constraint checking explicit, independently from any chosen method, it is possible to develop a new method that is optimal with respect to the classified redundancy aspects. We distinguish three types of redundancy and propose an integrity checking method based on revised inconsistency rules.

Repository support for multi-perspective requirements engineering

Relationships among different modeling perspectives have been systematically investigated focusing either on given notations (e.g. UML) or on domain reference models (e.g. ARIS/SAP). In contrast, many successful informal methods for business analysis and requirements engineering (e.g. JAD) emphasize team negotiation, goal orientation and flexibility of modeling notations. This paper addresses the question how much formal and computerized support can be provided in such settings without destroying their creative tenor. Our solution is based on a novel modeling language, M-Telos, that integrates the adaptability and analysis advantages of the logic-based meta modeling language Telos with a module concept covering the structuring mechanisms of scalable software architectures. It comprises four components: (1) A modular conceptual modeling formalism organizes individual perspectives and their interrelationships. (2) Perspective schemata are linked to a conceptual meta meta model of shared domain terms, thus giving the architecture a semantic meaning and enabling adaptability and extensibility of the network of perspectives. (3) Inconsistency management across perspectives is handled in a goal-oriented manner, by formalizing analysis goals as meta rules which are automatically customized to perspective schemata. (4) Continuous incremental maintenance of inconsistency information is provided by exploiting recent view maintenance techniques from deductive databases. The approach has been implemented as an extension to the ConceptBase ‡ ‡ ConceptBase is available through web site http://www-i5.Informatik.RWTH-Aachen.de/Cbdor/index.html. meta database management system and has been applied in a number of real-world requirements engineering projects.

Review: Deductive Databases and their Applications

Review: Deductive Databases and their Applications Geoff Franklin, Reviewed by Geoff Franklin, Reviewed by Partner, Alvechurch Data Techniques Search for other works by this author on: Oxford Academic Google Scholar The Computer Bulletin, Volume 41, Issue 2, March 1999, Page 31, https://doi.org/10.1093/combul/41.2.31-a Published: 01 March 1999

Deductive database languages

Deductive databases result from the integration of relational database and logic programming techniques. However, significant problems remain inherent in this simple synthesis from the language point of view. In this paper, we discuss these problems from four different aspects: complex values, object orientation, higher-orderness, and updates. In each case, we examine four typical languages that address the corresponding issues.

Meta-Queries on Deductive Databases

We introduce the notion of a meta-query on relational databases and a technique which can be used to represent and solve a number of interesting problems from the area of knowledge representation using logic. The technique is based on the use of quantifier elimination and may also be used to query relational databases using a declarative query language called SHQL (Semi-Horn Query Language), introduced in [6]. SHQL is a fragment of classical first-order predicate logic and allows us to define a query without supplying its explicit definition. All SHQL queries to the database can be processed in polynomial time (both on the size of the input query and the size of the database). We demonstrate the use of the technique in problem solving by structuring logical puzzles from the Knights and Knaves domain as SHQL meta-queries on relational databases. We also provide additional examples demonstrating the flexibility of the technique. We conclude with a description of a newly developed software tool, The Logic Engineer, which aids in the description of algorithms using transformation and reduction techniques such as those applied in the meta-querying approach.

Processing Deductive Databases under the Disjunctive Stable Model Semantics

Cyclic covers are shown to characterise disjunctive stable models of unstratified deductive databases, and to facilitate top-down query processing, query compilation and view updating under the disjunctive stable model semantics. Such processing is shown to be more complex than comparable processing of stratified databases.

Computing extended abduction through transaction programs

To explain observations from nonmonotonic background theories, one often needs removal of some hypotheses as well as addition of other hypotheses. Moreover, some observations should not be explained, while some are to be explained. In order to formalize these situations, extended abduction was introduced by Inoue and Sakama (1995) to generalize traditional abduction in the sense that it can compute negative explanations by removing hypotheses and antidexplanations to unexplain negative observations. In this paper, we propose a computational mechanism for extended abduction. When a background theory is written in a normal logic program, we introduce its transaction program for computing extended abduction. A transaction program is a set of nonddeterministic production rules that declaratively specify addition and deletion of abductive hypotheses. Abductive explanations are then computed by the fixpoint of a transaction program using a bottomdup model generation procedure. The correctness of the proposed procedure is shown for the class of acyclic covered abductive logic programs. In the context of deductive databases, a transaction program provides a declarative specification of database update.

Reasoning about Textual Similarity in a Web-Based Information Access System

The degree to which information sources are pre-processed by Web-based information systems varies greatly. In search engines like Altavista, little pre-processing is done, while in “knowledge integration” systems, complex site-specific “wrappers” are used to integrate different information sources into a common database representation. In this paper we describe an intermediate point between these two models. In our system, information sources are converted into a highly structured collection of small fragments of text. Database-like queries to this structured collection of text fragments are approximated using a novel logic called WHIRL, which combines inference in the style of deductive databases with ranked retrieval methods from information retrieval (IR). WHIRL allows queries that integrate information from multiple Web sites, without requiring the extraction and normalization of object identifiers that can be used as keys; instead, operations that in conventional databases require equality tests on keys are approximated using IR similarity metrics for text. This leads to a reduction in the amount of human engineering required to field a knowledge integration system. Experimental evidence is given showing that many information sources can be easily modeled with WHIRL, and that inferences in the logic are both accurate and efficient.

OLDTNF-based evaluation method for handling recursive queries in deductive databases

OLDTNF resolution is an important mechanism used in a Prolog interpreter. This mechanism is extended and improved for evaluating recursive queries in deductive databases. The key idea of the refinement is to distinguish between two classes of lookup nodes in an OLDTNF derivation and to handle them differently. First, reduce the search space by cutting of any subtree rooted at a lookup node of the first class. Further, speed up the evaluation by processing the second class in a second phase and generate many solutions directly from the solutions already produced (and the corresponding keys of solution lists) instead of evaluating them by expanding the corresponding subtrees in terms of the new solutions stored in solution lists.

A Novel Algorithm and its Hardware Support for the Run-Time Detection of And-Parallelism

It is well established in query evaluation literature that pushing constants (i.e. bound variable values) through selections, enables the problem specific information to be used effectively and is essential for constraining a query's search space. This amounts to a decision on how information gained about bindings in some body atom in a clause is to be used in evaluating other atoms in the clause. This binding passing algorithm is referred to in deductive database literature as a 'sideways information passing strategy' (sip). A sip that is determined at compile-time for uncovered definite clauses can only devise the most general sip and therefore may be sub-optimal at run-time. A sip determined at run-time is however inefficient - overheads outweigh advantages. To overcome these dilemmas a dynamic sip has been devised that uses a hybrid compile-time analysis, based on abstract interpretation, combined with a run-time verification. The pragmatics of the run-time verification is presented in this paper along with its novel hardware support providing a uniform performance of 155ns independent of the number of body atoms to detect an initial processing order for the independent atoms.

Update rules in datalog programs

We propose a deductive database model containing two kinds of rules: update rules of the form L0←L1, where L0 and L1 are literals, and query rules of the form of normal logic program rules. A basic feature of our approach is that new knowledge inputs are always assimilated. Moreover, updates are always deterministic and they preserve database consistency. We consider that update rules have higher priority than query rules, i.e., update rules may generate exceptions to query-driven derivations. We introduce a semantics framework for database update and query answering, based on the well-founded semantics. We also suggest an alternative approach based on extended logic programs and we show that our database model can be defined in terms of non-monotonic formalisms.

ISF: A Visual Formalism for Specifying Interconnection Styles for Software Design

We have developed a framework for specifying high-level software designs. The core of the framework is a very simple visual notation. This notation enables designers to document designs as labelled rectangles and directed edges. In addition to the notation, our framework features a supporting formalism, called ISF (Interconnection Style Formalism). This formalism enables designers to customize the simple design notation by specifying the type of entities, relations, legal configurations of entities and relations, as well as scoping rules of the custom notation. In this paper we present the formal definition of ISF and use ISF to specify two custom design notations. We also describe how ISF specifications, using deductive database technology, are used to generate supporting tools for these custom notations.

Extending the superimposed codeword indexing scheme to handle incomplete information

In order to use Prolog as a basis for database applications, techniques are required for rapid retrieval of clauses from large data sets. Various researchers have contributed to the development of indexing strategies for this purpose. One such strategy is known as superimposed codeword+mask bits (SCW+MB). One extension of Prolog which is useful in the development of deductive databases is the ability to handle incomplete information. A form of incomplete information based on sets has been introduced and used in a deductive database system. In order to provide efficient access to clauses containing incomplete information, existing strategies need to be adapted accordingly. This paper presents an extension to the SCW+MB algorithm to cover incomplete information, and describes how this can be realized in hardware.