An Inference Rule for the Acyclicity Property of Term Algebras

Term algebras are important structures in many areas of mathematics and computer science. Reasoning about their theories in superposition-based first-order theorem provers is made difficult by the acyclicity property of terms, which is not finitely axiomatizable. We present an inference rule that extends the superposition calculus and allows reasoning about term algebras without axioms to describe the acyclicity property. We detail an indexing technique to efficiently apply this rule in problems containing a large number of clauses. Finally we experimentally evaluate an implementation of this extended calculus in the first-order theorem prover Vampire. The results show that this technique is able to find proofs for difficult problems that existing SMT solvers and first-order theorem provers are unable to solve

Relational Programming in miniKanren: Techniques, Applications, and Implementations

Thesis (Ph.D.) - Indiana University, Computer Sciences, 2009The promise of logic programming is that programs can be written relationally, without distinguishing between input and output arguments. Relational programs are remarkably flexible—for example, a relational type-inferencer also performs type checking and type inhabitation, while a relational theorem prover generates theorems as well as proofs and can even be used as a simple proof assistant. Unfortunately, writing relational programs is difficult, and requires many interesting and unusual tools and techniques. For example, a relational interpreter for a subset of Scheme might use nominal unification to support variable binding and scope, Constraint Logic Programming over Finite Domains (CLP(FD)) to implement relational arithmetic, and tabling to improve termination behavior. In this dissertation I present miniKanren, a family of languages specifically designed for relational programming, and which supports a variety of relational idioms and techniques. I show how miniKanren can be used to write interesting relational programs, including an extremely flexible lean tableau theorem prover and a novel constraint-free binary arithmetic system with strong termination guarantees. I also present interesting and practical techniques used to implement miniKanren, including a nominal unifier that uses triangular rather than idempotent substitutions and a novel “walk”-based algorithm for variable lookup in triangular substitutions. The result of this research is a family of languages that supports a variety of relational idioms and techniques, making it feasible and useful to write interesting programs as relations

Object-oriented implementation of Prolog

Logic programming is a discipline of describing problems in high-level abstraction by separating logic from control. Conventional Prolog interpretation or compilation models take a procedural view of Prolog programs. A description of interpretation models was summarized by Bruynooghe[Bru82] and a well-known compilation model was introduced by Warren[War83]. The goal of this study is to present an alternative approach to construct Prolog execution model to tackle the complexities caused by conventional Prolog execution models. By taking the advantage of object-oriented techniques, a new model - object-oriented model is proposed. Instead of decomposing a given Prolog program into a set of procedures, the model translates it into a collection of coordinated objects which simulate components of the problem to be solved. First, the object-oriented model is described in terms of the object base and inference engine. The object base represents the components of Prolog programs naturally with corresponding objects in terms of AND/OR network. The inference engine, which specifies the operational behaviour of the objects, is embedded in the object base and independent of any specific Prolog program. Secondly, implementation issues of a Prolog system based on the object-oriented model are presented. A transformation program is developed to translate any given Prolog program into a set of objects and assign the corresponding relations among them. The implementation of the inference engine adopts Robinson’s resolution [Rob79] which consists of two major algorithms; unification and backtracking. Finally, the first parameter hashing optimization and a uniform interface to adopt new built-in predicates are addressed to show the extensibility of proposed Prolog system. An experimental object-oriented Prolog system, LU-Prolog, has been developed based on the proposed model. An evaluation of the performance of LU-Prolog and its future directions are also presented in this thesis