## An Overview of λProlog (1988)

### Cached

### Download Links

Venue: | In Fifth International Logic Programming Conference |

Citations: | 100 - 35 self |

### BibTeX

@INPROCEEDINGS{Nadathur88anoverview,

author = {Gopalan Nadathur and Dale Miller},

title = {An Overview of λProlog},

booktitle = {In Fifth International Logic Programming Conference},

year = {1988},

pages = {810--827},

publisher = {MIT Press}

}

### Years of Citing Articles

### OpenURL

### Abstract

Abstract: λProlog is a logic programming language that extends Prolog by incorporating notions of higher-order functions, λ-terms, higher-order unification, polymorphic types, and mechanisms for building modules and secure abstract data types. These new features are provided in a principled fashion by extending the classical first-order theory of Horn clauses to the intuitionistic higher-order theory of hereditary Harrop formulas. The justification for considering this extension a satisfactory logic programming language is provided through the proof-theoretic notion of a uniform proof. The correspondence between each extension to Prolog and the new features in the stronger logical theory is discussed. Also discussed are various aspects of an experimental implementation of λProlog. Appears in the Fifth International Conference Symposium on Logic Programming, 15 – 19 August 1988, Seattle, Washington. This is a slightly corrected version of

### Citations

375 | Uniform proofs as a foundation for logic programming
- Miller, Nadathur, et al.
- 1991
(Show Context)
Citation Context ...s are removed by using equivalences in classical logic and by interpreting negation with negation-by-failure. The association between logical connectives and search operations is defined precisely in =-=[24]-=-. This definition is a refinement of the one in [23] and can be summarized as follows. Let L be a formulation of quantificational logic containing at least the logical connectives ∧, ∨, ⊃, ∀, and ∃. L... |

303 |
Higher-order abstract syntax
- Pfenning, Elliott
- 1988
(Show Context)
Citation Context ...or the programmer to deal with variable names and to implement the various substitution operations that would be needed. In contrast, λ-terms capture the higher-order abstract syntax of these objects =-=[30]-=-. Using them as representational devices makes the handling of bound variable names, substitutions, variable capturing, etc., part of the meta theory of the programming language. Consequently the mech... |

192 |
The art of Prolog: advanced programming techniques
- Sterling, Shapiro
- 1986
(Show Context)
Citation Context ...ndence to gopalan@cs.duke.edu or dale@linc.cis.upenn.edu or to the addresses above. – 1 –1. Introduction 1. Introduction The logic programming language λProlog is an extension of conventional Prolog =-=[32]-=- in several different directions: it supports higher-order programming, incorporates λ-terms as data structures, includes a notion of polymorphic typing, and provides mechanisms for defining modules a... |

90 |
A Theory of Type Polymorphism
- Milner
- 1978
(Show Context)
Citation Context ...the former are actually typed formulas. The essential role of types here is to impose a functional hierarchy on terms. From a programming perspective, these types provide an ML-like typing discipline =-=[25]-=- to Prolog. Such types add an element of documentation to programs, and type errors detected at parsing time identify goals that will never succeed. The typing scheme (which initially uses only primit... |

81 | Partial polymorphic type inference and higher-order unification
- Pfenning
- 1988
(Show Context)
Citation Context .... Observations such as these have in fact been ex– 8 –3. Programming Language Consequences ploited to provide succinct implementations of theorem-provers, interpreters, and type inference procedures =-=[2, 20, 22, 27, 29]-=-. As another example, λ-terms turn out to be particularly apt for representing programs that contain formal parameters or local variables. Arguments similar to those above show that a logic programmin... |

54 | Natural deduction as higher-order resolution - Paulson - 1986 |

39 |
Natural Deduction. Almqvist
- Prawitz
- 1965
(Show Context)
Citation Context ...d interpreter for Prolog essentially by replacing first-order unification with higher-order unification. In our analysis of higher-order Horn clauses, we represented proofs using the sequent calculus =-=[4, 31]-=- instead of the more traditional format of resolution refutations. This turned out to be rather fortunate because we were able to observe certain structural properties of sequent proofs involving posi... |

34 |
A Higher-Order Logic as the Basis for Logic Programming
- Nadathur
- 1987
(Show Context)
Citation Context ...Foundation in Horn Clauses aspect for which an analysis was missing from the literature. As it turned out, we succeeded in solving the problem of predicate substitutions for higher-order Horn clauses =-=[26]-=-. This solution did not shed much light on the general theorem proving problem: the Horn clause setting is so weak that the needed predicate substitutions can be determined solely through higher-order... |

28 |
Hereditary Harrop formulas and uniform proof systems
- Miller, Nadathur, et al.
- 1987
(Show Context)
Citation Context ...ng the addition of implications to the body of definite clauses was described in [16, 18]. A further extension that permitted universal quantification in the body of definite clauses was described in =-=[17, 23]-=-. This final extension is what we refer to as hereditary Harrop formulas. Our criterion for judging the adequacy of a logical theory as the basis for logic programming may be explained as follows: the... |

1 |
The Foundations of a Generic Theorem Prover. University of Cambridge technical report 130
- Paulson
- 1988
(Show Context)
Citation Context ...e resulting unifier is used to determine the instance of G that must be solved next. The approach to dealing with universal quantification outlined above is similar to a technique called ∀-lifting in =-=[28]-=-. There is an alternative scheme that essentially preserves the naive implementation of INSTANCE and GENERIC, and modifies the unification process instead. The basic idea here is to use an environment... |