Abstract not found

The unification problem and several variants are presented. Various algorithms and data structures are discussed. Research on unification arising in several areas of computer science is surveyed, these areas include theorem proving, logic programming, and natural language processing. Sections of the paper include examples that highlight particular uses

In order to find a static type system that adequately supports database languages, we need to express the most general type of a program that involves database operations. This can be achieved through an extension to the type system of ML that captures the polymorphic nature of field selection, together with a technique that generalizes relational operators to arbitrary data structures. The combination provides a statically typed language in which generalized relational databases may be cleanly represented as typed structures. As in ML types are inferred, which relieves the programmer of making the type assertions that may be required in a complex database environment. These extensions may also be used to provide static polymorphic typechecking in object-oriented languages and databases. A problem that arises with object-oriented databases is the apparent need for dynamic typechecking when dealing with queries on heterogeneous collections of objects. An extension of the type system needed for generalized relational operations can also be used for manipulating collections of dynamically typed values in a statically typed language. A prototype language based on these ideas has been implemented. While it lacks a proper treatment of persistent data, it demonstrates that a wide variety of database structures can be cleanly represented in a polymorphic programming language.

Functional and logic programming are the most important declarative programming paradigms, and interest in combining them has grown over the last decade. Early research concentrated on the definition and improvement of execution principles for such integrated languages, while more recently efficient implementations of these execution principles have been developed so that these languages became relevant for practical applications. In this paper we survey the development of the operational semantics as well as

ion variables which are variables coming from an abstraction, either during preprocessing or during the algorithm itself. 3. Introduced variables which are variables introduced by the unification algorithms for each theory. We make the very natural assumption that the unification algorithm for each theory may recognize initial, abstraction and introduced variables and never assigns an introduced variable to a non-introduced one or an abstraction variable to an initial one. With this assumption, our combination algorithm will always make an introduced variable appear in at most one \Gamma i . We may thus also suppose that the domain of each solution does not contain an introduced variable. This does not compromise the soundness of our algorithm. The combination algorithm is described by the two rules given in figure 2. In the rule UnifSolve i , ae SF is obtained by abstracting aliens in the range of ae by fresh variables. ae F i is the substitution such that xae = xae SF ae F i for al...

Functional logic overloading is a novel approach to userdefined overloading that extends Haskell’s concept of type classes in significant ways. Whereas type classes are conceptually predicates on types in standard Haskell, they are type functions in our approach. Thus, we can base type inference on the evaluation of functional logic programs. Functional logic programming provides a solid theoretical foundation for type functions and, at the same time, allows for programmable overloading resolution strategies by choosing different evaluation strategies for functional logic programs. Type inference with type functions is an instance of type inference with constrained types, where the underlying constraint system is defined by a functional logic program. We have designed a variant of Haskell which supports our approach to overloading, and implemented a prototype frontend for the language.

. Unification in the presence of an equational theory is an important problem in theorem-proving and in the integration of functional and logic programming languages. This paper presents an improvement of the proposed lazy unification methods by incorporating simplification into the unification process. Since simplification is a deterministic computation process, more efficient unification algorithms can be achieved. Moreover, simplification reduces the search space so that in some case infinite search spaces are reduced to finite ones. We show soundness and completeness of our method for equational theories represented by ground confluent and terminating rewrite systems which is a reasonable class w.r.t. functional logic programming. 1 Introduction Unification is not only an important operation in theorem provers but also the most important operation in logic programming systems. Unification in the presence of an equational theory, also known as E-unification, is necessary...

One of the key issues in Automated Theorem Proving is the search for optimal proof strategies. Since there is not one uniform strategy which works optimal on all proof tasks, one is faced with the difficult problem of selecting a good strategy for a given task. In this paper, we discuss a way of circumventing this strategy selection problem by using strategy parallelism. In this approach, a proof task is attempted in parallel by a set of uniform strategies while distributing the given amount of computing resources according to a certain schedule. We discuss important issues of strategy parallelism like search space partitioning, schedule computation, and scalability. In order to evaluate the potential of the method experimentally, we have implemented the strategy parallel theorem prover p-SETHEO, which is also described in the paper. The experimental results obtained with the system justify our approach. 1 Introduction Automated Theorem Proving (ATP) is the subfield of theoretical co...

Languages that integrate functional and logic programming styles with a complete operational semantics are based on narrowing. In order to avoid useless computations, lazy narrowing strategies have been proposed in the past. This paper presents an improvement of lazy narrowing by incorporating deterministic simplification steps into lazy narrowing derivations. These simplification steps reduce the search space so that in some cases infinite search spaces are reduced to finite ones. We consider two classes of programs where this strategy can be applied. Firstly, we show soundness and completeness of our strategy for functional logic programs based on ground confluent and terminating rewrite systems. Then, we show similar results for constructor-based weakly orthogonal (not necessarily terminating) rewrite systems. Finally, we demonstrate the improved operational behavior by means of several examples. Since most functional logic languages are based on programs belonging to one of these classes, our result is a significant step to improve the operational semantics of existing functional logic languages.

Let E be a first-order equational theory. A translation of typed higher-order E-unification problems into a typed combinatory logic framework is presented and justified. The case in which E admits presentation as a convergent term rewriting system is treated in detail: in this situation, a modification of ordinary narrowing is shown to be a complete method for enumerating higher-order E-unifiers. In fact, we treat a more general problem, in which the types of terms contain type variables. 1 Introduction Investigation of the interaction between first-order and higher-order equational reasoning has emerged as an active line of research. The collective import of a recent series of papers, originating with [Bre88] and including (among others) [Bar90], [BG91a], [BG91b], [Dou92], [JO91] and [Oka89], is that when various typed -calculi are enriched by first-order equational theories, the validity problem is well-behaved, and furthermore that the respective computational approaches to ...