Lawrence J. Henschen

Deduction in non-Horn databases

The class of non-Horn, function-free databases is investigated and several aspects of the problem of using theorem proving techniques for such databases are considered. This includes exploring the treatment of negative information and extending the existing method, suggested by Minker, to accept non-unit negative clauses. It is shown that the algorithms based on the existing methods for the treatment of negative information can be highly inefficient. An alternative approach is suggested and a simpler algorithm based on it is given. The problems associated with query answering in non-Horn databases are addressed and compared with those for the Horn case. It is shown that the query evaluation process can be computationaly difficult in the general case. Conditions under which the process is simplified are discussed. The topic of non-Horn general laws is considered and some guidelines are suggested to divide such laws into derivation rules and integrity constraints. The effect of such a division on the query evaluation process is discussed.

Unit Refutations and Horn Sets

The key concepts for this automated theorem-proving paper are those of Horn set and strictly-unit refutation. A Horn set is a set of clauses such that none of its members contains more than one positive literal. A strictly-unit refutation is a proof by contradiction in which no step is justified by applying a rule of inference to a set of clauses all of which contain more than one literal. Horn sets occur in many fields of mathematics such as the theory of groups, rings, Moufang loops, and Henkin models. The usual translation into first-order predicate calculus of the axioms of these and many other fields yields a set of Horn clauses. The striking feature of the Horn property for finite sets of clauses is that its presence or absence can be determined by inspection. Thus, the determination of the applicability of the theorems and procedures of this paper is immediate. In Theorem 1 it is proved that, if S is an unsatisfiable Horn set, there exists a strictly-unit refutation of S employing binary resolution alone, thus eliminating the need for factoring; moreover, one of the immediate ancestors of each step of the refutation is in fact a positive unit clause. A theorem similar to Theorem 1 for paramodulation-based inference systems is proven in Theorem 3 but with the inclusion of factoring as an inference rule. In Section 3 two reduction procedures are discussed. For the first, Changs splitting, a rule is provided to guide both the choice of clauses and the way in which to split. The second reduction procedure enables one to refute a Horn set by refuting but one of a corresponding family of simpler subproblems.

COMPILING CONSTRAINT-CHECKING PROGRAMS FROM FIRST-ORDER FORMULAS

We describe a technique for extracting integrity tests from database constraints expressed as first-order formulas. The tests can be generated at database design time and are to be applied when updates to the database are issued. A significant feature is that the tests are to be applied before the update is made. The basic method is to assert a constraint for the current state of the database, express the new state in terms of both the old state and the general form of the update, deny that the constraint holds in the new state, and attempt to obtain a contradiction. When no contradiction is found, tests are to be extracted from the formulas generated and represent, in effect, a set of reasons why a contradiction could not be found, i.e., what extra conditions must be verified to guarantee the constraint in the new state. Some general results are given and open problems about the method are discussed.

Using domain knowledge in knowledge discovery

With the explosive growth of the size of databases, many knowledge discovery applications deal with large quantities of data. There is an urgent need to develop methodologies which will allow the applications to focus search to a potentially interesting and relevant portion of the data, which can reduce the computational complexity of the knowledge discovery process and improve the interestingness of discovered knowledge. Previous work on semantic query optimization, which is an approach to take advantage of domain knowledge for query optimization, has demonstrated that significant cost reduction can be achieved by reformulating a query into a less expensive yet equivalent query which produces the same answer as the original one. In this paper, we introduce a method to utilize three types of domain knowledge in reducing the cost of finding a potentially interesting and relevant portion of the data while improving the quality of discovered knowledge. In addition, we propose a method to select relevant domain knowledge without an exhaustive search of all domain knowledge. The contribution of this paper is that we lay out a general framework for using domain knowledge in the knowledge discovery process effectively by providing guidelines.

A new use of an automated reasoning assistant: open questions in equivalential calculus and the study of infinite domains

Abstract The field of automated reasoning is an outgrowth of the field of automated theorem proving. The difference in the two fields is not so much in the procedures on which they rest, but rather in the way the corresponding programs are used. Here we present a comprehensive treatment of the use of an automated reasoning program to answer certain previously open questions from equivalential calculus. The questions are answered with a uniform method that employs schemata to study the infinite domain of theorems deducible from certain formulas. We include sufficient detail both to permit the work to be duplicated and to enable one to consider other applications of the techniques. Perhaps more important than either the results or the methodology is the demonstration of how an automated reasoning program can be used as an assistant and a colleague. Precise evidence is given of the nature of this assistance.

Automatic theorem proving in paraconsistent logics: theory and implementation

Databases and knowledge bases may be inconsistent in many ways. However, a database that is inconsistent may, nonetheless, contain a great deal of useful information. Classical logic, however, would deem such a database as useless. Paraconsistent logics are a family of logics introduced by da Costa. A family of paraconsistent logics called annotated logics were proposed by Subrahmanian in [17]. Subsequently, these logics found use in reasoning about logic programs that contained inconsistent and/or erroneous information, as well as in the study of inheritance hierarchies and object oriented databases. However, no full-fledged study of automatic theorem proving in these logics has been carried out to date. In this paper, we develop a linear resolution style proof procedure for mechanical reasoning in these paraconsistent logics.

Handling redundancy in the processing of recursive database queries

Redundancy may exist in the processing of recursive database queries at four different levels precompilation level, iteration level, tuple processing level and file accessing level. Techniques for reducing redundant work at each level are studied. In the precompilation level, the optimization techniques include removing redundant parts in a rule cluster, simplifying recursive clusters and sharing common subexpressions among rules. At the iteration level, the techniques discussed are the use of frontier relations and the counting method. At the tuple processing level, we use merging and filtering methods to exclude processed drivers from database reaccessing. Finally, at the file accessing level, I/O cost can be further reduced by level relaxation. We conclude that even for complex recursion, redundant database processing can be considerably reduced or eliminated by developing appropriate algorithms.

A new robot navigation algorithm for dynamic unknown environments based on dynamic path re-computation and an improved scout ant algorithm

A difficult issue in robot navigation or path planning in an unknown environment with static or dynamic obstacles is to find a globally optimal path from the start to the target point and at the same time avoid collisions. We present a novel and effective robot navigation algorithm for dynamic unknown environments based on an improved ant-based algorithm. In our approach two bidirectional groups of scout ants cooperate with each other to find a local optimal static navigation path within the visual domain of the robot. The robot then predicts the collision points with moving objects, and the scout ants find a new collision-free local navigation path. This process is carried out dynamically after each step of the robot, thereby allowing the robot to adjust its path as new obstacles come into view or existing obstacles move in new directions. Therefore, the robot can not only avoid collision but also make its paths globally optimal or near-optimal by making a series of dynamic adjustments to locally optimal paths. The simulation results have shown that the algorithm has good effect, high real-time performance, and is very suitable for real-time navigation in complex and dynamic environments.

Efficient algorithms for the instantiated transitive closure queries

The performances of several algorithms suitable for processing an important class of recursive queries called the instantiated transitive closure (TC) queries are studied and compared. These algorithms are the wavefront, delta -wavefront, and a generic algorithm called super-TC. During the evaluation of a TC query, the first two algorithms may read a given disk page more than once, whereas super-TC reads the disk page at most once. A comprehensive performance evaluation of these three algorithms using rigorous analytical and simulation models is presented. The study reveals that the relative performance of the algorithms is a strong function of the parameters which characterize the processed TC query and the relation referenced by that query. The superiority of one of the super-TC variants over all of the other presented algorithms is shown. >

Classification of recursive formulas in deductive databases

In this paper, we present results on the classification of linear recursive formulas in deductive databases and apply those results to the compilation and optimization of recursive queries. We also introduce compiled formulas and query evaluation plans for a representative query for each of these classes. To explain general recursive formulas, we use a graph model that shows the connectivity between variables. The connecticity between variables is the most critical part in processing recursive formulas. We demonstrate that based on such a graph model all the linear recursive formulas can be classified into several classes and each class shares some common characteristics in compilation and query processing. The compiled formulas and the corresponding query evaluation plans can be derived based on the study of the compilation of each class.