Recursive Predicates Research Articles

On the completeness of naive memoing in Prolog

Memoing is often used in logic programming to avoid redundant evaluation of similar goals, often on programs that are inherently recursive in nature. The interaction between memoing and recursion, however, is quite complex. There are several top-down evaluation strategies for logic programs that utilize memoing to achieve completeness in the presence of recursion. This paper’s focus, however, is on the use ofnaive memoing in Prolog. Using memoingnaively in conjunction with recursion in Prolog may not produce expected results. For example, adding naive memoing to Prolog’s evaluation of a right-recursive transitive closure may be incomplete, whereas adding naive memoing to Prolog’s evaluation of a left-recursive transitive closure may be terminating and complete. This paper examines the completeness of naive memoing in linear-recursive, function-free logic programs evaluated with Prolog’s top-down evaluation strategy. In addition, we assume that the program is definite and safe, having finite base relations and exactly one recursive predicate. The goal of the paper is a theoretical study of the completeness of naive memoing and recursion in Prolog, illustrating the limitations imposed even for this simplified class of programs. The naive memoing approach utilized for this study is based on extension tables, which provide a memo mechanism with immediate update view semantics for Prolog programs, through a source transformation known as ET. We introduce the concept ofET-complete, which refers to the completeness of the evaluation of a query over a Prolog program that memos selected predicates through the ET transformation. We show that left-linear recursions defined by a single recursive rule are ET-complete. We generalize the class of left-linear recursions that are ET-complete by introducing pseudo-left-linear recursions, which are also defined by a single linear recursive rule. To add left-linear recursions defined bymultiple linear recursive rules to the class of ET-complete recursions, we present a left-factoring algorithm that converts left-linear recursions defined by multiple recusive rules into pseudo-left-linear recursions defined by a single recursive rule. Based on these results, the paper concludes by identifying research directions for expanding the class of Prolog programs to be examined in future work.

Classifying Predicates and Languages

The present paper studies a particular collection of classification problems, i.e., the classification of recursive predicates and languages, for arriving at a deeper understanding of what classification really is. In particular, the classification of predicates and languages is compared with the classification of arbitrary recursive functions and with their learnability. The investigation undertaken is refined by introducing classification within a resource bound resulting in a new hierarchy. Furthermore, a formalization of multi-classification is presented and completely characterized in terms of standard classification. Additionally, consistent classification is introduced and compared with both resource bounded classification and standard classification. Finally, the classification of families of languages that have attracted attention in learning theory is studied, too.

Effective category and measure in abstract complexity theory

Strong variants of the Operator Speed-up Theorem, Operator Gap Theorem and Compression Theorem are obtained using an effective version of Baire Category Theorem. It is also shown that all complexity classes of recursive predicates have effective measure zero in the space of recursive predicates and, on the other hand, the class of predicates with almost everywhere complexity above an arbitrary recursive threshold has recursive measure one in the class of recursive predicates.

On the Expected Size of Recursive Datalog Queries

We present asymptotically exact expressions for the expected sizes of relations defined by three well-studied Datalog recursions, namely the "transitive closure," "same generation," and "canonical factorable recursion." We consider the size of the fixpoints of the recursively defined relations in the above programs, as well as the size of the fixpoints of the relations defined by the rewritten programs generated by the Magic Sets and Factoring rewriting algorithms in response to selection queries. Our results show that even over relatively sparse base relations, the fixpoints of the recursively defined relations are within a small constant factor of their worst-case size bounds, and that the Magic Sets rewriting algorithm on the average produces relations whose fixpoints are within a small constant factor of the corresponding bounds for the recursion without rewriting. The expected size of the fixpoint of the relations produced by the Factoring algorithm, when it applies, is significantly smaller than the expected size of the fixpoints of the relations produced by Magic Sets. This lends credence to the belief that reducing the arity of the recursive predicate is probably more important than restricting the recursion to relevant tuples.

Argument reduction by factoring

We identify a useful property of a program with respect to a predicate, calledfactoring. While we prove that detecting factorability is undecidable in general, we show that for a large class of programs, the program obtained by applying the Magic Sets transformation is factorable with respect to the recursive predicate. When the factoring property holds, a simple optimization of the program generated by the Magic Sets transformation results in a new program that is never less efficient than the Magic Sets program and is often dramatically more efficient, due to the reduction of the arity of the recursive predicate. We show that the concept of factoring generalizes some previously identified special cases of recursions, including separable recursions and right- and left-linear recursions.

A Single Recursive Predicate Is Sufficient for Pure Datalog

Datalog is a query language for relational databases. The set of predicate symbols in a Datalog program is partioned into EDB (extensional database) and IDB (intensional database) predicates; intuitively, the EDB predicates refer to a stored relational database while the IDB predicates refer to relations to be deduced from the EDB. We show that for each Datalog program there exists a Datalog program having at most one recursive predicate that computes the same IDB extensions. A similar result was obtained by Chandra and Harel. However, they used the built-in predicate ≠. This built-in predicate is not part of the repertoire of pure Datalog and is not used in the construction of this paper.

Permutation dependency in datalog programs

An efficient scheme for maintaining minimal knowledge in the presence of a permutation dependency is presented. Because this scheme eliminates the redundancy in the initial value of the recursive predicate, the cost of query processing is reduced by a constant factor. Thus, the method improves over other conventional methods both in space and time. We also present an optimization strategy based upon identification and removal of redundant rules from a Datalog program.

A parallel pipelined strategy for evaluating linear recursive predicates in a multiprocessor environment

A parallel pipelined strategy for evaluating single linear recurssive predicates in a multiprocessor system is described. A top-down compiling technique generates the resolvents corresponding to the recursive predicate. While evaluating the resolvents against the database relations, the proposed strategy exploits three database query optimization techniques. We develop an analytical model for the proposed evaluation strategy; it models the execution of the pipelined butterfly hash-join operation. In an analytical performance evaluation, we compare the proposed strategy with a sequential and parallel bottom-up semi-naive algorithm, for computing the transitive closure of a database relation. We measure the response time and execution time for each resolvent. The speedup demonstrates the benefits of the parallel pipelined strategy; the performance evaluation indicates that it can increasingly benefit from each additional processor used, as larger relations are passed along the pipeline. A steady pipeline can be maintained even when hash table overflow occurs due to memory limitations.

Comparison of methods for logic-query implementation

A logic query Q is a triple < G, LP, D, where G is the query goal, LP is a logic program without function symbols, and D is a set of facts, possibly stored as tuples of a relational database. The answers of Q are all facts that can be inferred from LP ∪ D and unify with G. A logic query is bound if some argument of the query goal is a constant; it is canonical strongly linear (a CSL query) if LP contains exactly one recursive rule and this rule is linear, i.e., only one recursive predicate occurs in its body. In this paper, the problem of finding the answers of a bound CSL query is studied with the aim of comparing for efficiency some well-known methods for implementing logic queries: the eager method, the counting method, and the magic-set method. It is shown that the above methods can be expressed as algorithms for finding particular paths in a directed graph associated to the query. Within this graphical formalism, a worst-case complexity analysis of the three methods is performed. It turns out that the counting method has the best upper bound for noncyclic queries. On the other hand, since the counting method is not safe if queries are cyclic, the method is extended to safely implement this kind of queries as well.

Efficient evaluation for a subset of recursive queries

We consider the efficient evaluation of recursive queries in logic databases where the queries are expressed using a Datalog program (function-free Horn-clause program) that contains only regularly or linearly recursive predicates. Using well-known results on graph traversal, we develop an efficient algorithm for evaluating relations defined by a binary-chain program. We also present a transformation by which the evaluation of a subset of queries involving nonbinary relations can be reduced to the evaluation of binary-chain queries. This transformation is guided by the choice of bound arguments in the query, and the bindings are propagated through the program so that in the evaluation of the transformed program the bindings will be used to restrict the set of database facts consulted.

On the existence of nonterminating queries for a restricted class of PROLOG-clauses

This work studies the existence of nonterminating queries for a restricted class of recursive predicates. The class is restricted to predicates defined by a set of clauses containing only one (direct) recursive clause. Moreover, this clause must be of the form P(…):-P(…). For this restricted class of predicates, we prove a necessary and sufficient condition for the existence of a query which is nonterminating in the absence of the occur check. The condition is based upon concepts from rational trees.

Efficient evaluation of right-, left-, and multi-linear rules

We present an algorithm for the efficient evaluation of a useful subset of recursive queries. Like the magic sets transformation, the algorithm consists of a rewriting phase followed by semi-naive bottom-up evaluation of the resulting rules. We prove that on a wide range of recursions, this algorithm achieves a factor of Ο ( n ) speedup over magic sets. Intuitively, the transformations in this algorithm achieve their performance by reducing the arity of the recursive predicates in the transformed rules.

Approximate completeness in algebras of partial recursive functions and predicates

Approximate completeness in algebras of partial recursive functions and predicates

Magic counting methods

The problem considered is that of implementing recursive queries, expressed in a logic-based language, by efficient fixpoint computations. In particular, the situation is studied where the initial bindings in the recursive predicate can be used to restrict the search space and ensure safety of execution. Two key techniques previously proposed to solve this problem are (i) the highly efficient counting method, and (ii) the magic set method which is safe in a wider range of situations than (i). In this paper, we present a family of methods, called the magic counting methods, that combines the advantages of (i) and (ii). This is made possible by the similarity of the strategies used by the counting method and the magic set method for propagating the bindings. This paper introduces these new methods, examines their computational complexity, and illustrates the trade-offs between the family members and their superiority with respect to the old methods.

Finite approximate approach to the study of the complexity of recursive predicates

An extension of Blum's complexity axiomatics, which enables us to investigate the complexity of bounded approximations of recursive predicates under very general assumptions on the type of the computational process, is considered. The existence of minimal bounded approximations of recursive predicates and the possibility of obtaining unimprovable bounds on the complexity of minimal bounded approximations are proved. Definitive bounds on the complexity of bounded approximations are obtained under fixed concepts of the computational process (for finite automata and for Turing machines). A lower bound is obtained for the complexity of the minimal approximations for the predicate “occurrence.”

Families of recursive predicates of measure zero

Families of recursive predicates of measure zero

An intuitiomstic completeness theorem for intuitionistic predicate logic

The problem of treating the semantics of intuitionistic logic within the framework of intuitionistic mathematics was first attacked by E. W. Beth [1]. However, the completeness theorem he thought to have obtained, was not true, as was shown in detail in a report by V. H. Dyson and G. Kreisel [2]. Some vague remarks of Beth's, for instance in his book, The foundations of mathematics, show that he sustained the hope of restoring his proof. But arguments by K. Gödel and G. Kreisel gave people the feeling that an intuitionistic completeness theorem would be impossible [3]. (A (strong) completeness theorem would implyfor any primitive recursive predicate A of natural numbers, and one has no reason to believe this for the usual intuitionistic interpretation.) Nevertheless, the following contains a correct intuitionistic completeness theorem for intuitionistic predicate logic. So the old arguments by Godel and Kreisel should not work for the proposed semantical construction of intuitionistic logic. They do not, indeed. The reason is, loosely speaking, that negation is treated positively.Although Beth's semantical construction for intuitionistic logic was not satisfying from an intuitionistic point of view, it proved to be useful for the development of classical semantics for intuitionistic logic. A related and essentially equivalent classical semantics for intuitionistic logic was found by S. Kripke [4].

An intuitiomstic completeness theorem for intuitionistic predicate logic

The problem of treating the semantics of intuitionistic logic within the framework of intuitionistic mathematics was first attacked by E. W. Beth [1]. However, the completeness theorem he thought to have obtained, was not true, as was shown in detail in a report by V. H. Dyson and G. Kreisel [2]. Some vague remarks of Beth's, for instance in his book, The foundations of mathematics, show that he sustained the hope of restoring his proof. But arguments by K. Gödel and G. Kreisel gave people the feeling that an intuitionistic completeness theorem would be impossible [3]. (A (strong) completeness theorem would implyfor any primitive recursive predicate A of natural numbers, and one has no reason to believe this for the usual intuitionistic interpretation.) Nevertheless, the following contains a correct intuitionistic completeness theorem for intuitionistic predicate logic. So the old arguments by Godel and Kreisel should not work for the proposed semantical construction of intuitionistic logic. They do not, indeed. The reason is, loosely speaking, that negation is treated positively.Although Beth's semantical construction for intuitionistic logic was not satisfying from an intuitionistic point of view, it proved to be useful for the development of classical semantics for intuitionistic logic. A related and essentially equivalent classical semantics for intuitionistic logic was found by S. Kripke [4].

Iterated Limiting Recursion and the Program Minimization Problem

The general problem of finding minimal programs realizing given “program descriptions” is considered, where program descriptions may be of finite or infinite length and may specify arbitrary program properties. The problem of finding minimal programs consistent with finite or infinite input-output lists is a special case (for infinite input-output lists, this is a variant of E. M. Gold's function identification problem). Although most program minimization problems are not recursively solvable, they are found to be no more difficult than the problem of deciding whether any given program realizes any given description, or the problem of enumerating programs in order of nondecreasing length (whichever is harder). This result is formulated in terms of k -limiting recursive predicates and functionals, defined by repeated application of Gold's limit operator. A simple consequence is that the program minimization problem is limiting recursively solvable for finite input-output lists and 2-limiting recursively solvable for infinite input-output lists, with weak assumptions about the measure of program size. Gold regarded limiting function identification (more generally, “black box” identification) as a model of inductive thought. Intuitively, iterated limiting identification might be regarded as higher-order inductive inference performed collectively by an ever-growing community of lower order inductive inference machines.

Regular approximations of recursive predicates

Regular approximations of recursive predicates