A proof-theoretic characterization of logical languages that form suitable bases for Prolog-like programming languages is provided. This characterization is based on the principle that the declarative meaning of a logic program, provided by provability in a logical system, should coincide with its operational meaning, provided by interpreting logical connectives as simple and fixed search instructions. The operational semantics is formalized by the identification of a class of cut-free sequent proofs called uniform proofs. A uniform proof is one that can be found by a goal-directed search that respects the interpretation of the logical connectives as search instructions. The concept of a uniform proof is used to define the notion of an abstract logic programming language, and it is shown that first-order and higher-order Horn clauses with classical provability are examples of such a language. Horn clauses are then generalized to hereditary Harrop formulas and it is shown that first-order and higher-order versions of this new class of formulas are also abstract logic programming languages if the inference rules are those of either intuitionistic or minimal logic. The programming language significance of the various generalizations to first-order Horn clauses is briefly discussed.

this paper we describe Elf, a meta-language intended for environments dealing with deductive systems represented in LF. While this paper is intended to include a full description of the Elf core language, we only state, but do not prove here the most important theorems regarding the basic building blocks of Elf. These proofs are left to a future paper. A preliminary account of Elf can be found in [26]. The range of applications of Elf includes theorem proving and proof transformation in various logics, definition and execution of structured operational and natural semantics for programming languages, type checking and type inference, etc. The basic idea behind Elf is to unify logic definition (in the style of LF) with logic programming (in the style of Prolog, see [22, 24]). It achieves this unification by giving types an operational interpretation, much the same way that Prolog gives certain formulas (Horn-clauses) an operational interpretation. An alternative approach to logic programming in LF has been developed independently by Pym [28]. Here are some of the salient characteristics of our unified approach to logic definition and metaprogramming. First of all, the Elf search process automatically constructs terms that can represent object-logic proofs, and thus a program need not construct them explicitly. This is in contrast to logic programming languages where executing a logic program corresponds to theorem proving in a meta-logic, but a meta-proof is never constructed or used and it is solely the programmer's responsibility to construct object-logic proofs where they are needed. Secondly, the partial correctness of many meta-programs with respect to a given logic can be expressed and proved by Elf itself (see the example in Section 5). This creates the possibilit...

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

We describe Elf, a metalanguage for proof manipulation environments that are independent of any particular logical system. Elf is intended for meta-programs such as theorem provers, proof transformers, or type inference programs for programming languages with complex type systems. Elf unifies logic definition (in the style of LF, the Edinburgh Logical Framework) with logic programming (in the style of Prolog). It achieves this unification by giving types an operational interpretation, much the same way that Prolog gives certain formulas (Horn-clauses) an operational interpretation. Novel features of Elf include: (1) the Elf search process automatically constructs terms that can represent object-logic proofs, and thus a program need not construct them explicitly, (2) the partial correctness of meta-programs with respect to a given logic can be expressed and proved in Elf itself, and (3) Elf exploits Elliott's unification algorithm for a -calculus with dependent types. This research was...

Logic programming provides a uniform framework in which all aspects of explanation-based generalization and learning may be defined and carried out, but first-order Horn logic is not well suited to application domains such as theorem proving or program synthesis where functions and predicates are the objects of computation. We explore the use of a higher-order representation language and extend EBG to a higher-order logic programming language. Variables may now range over functions and predicates, which leads to an expansion of the space of possible generalizations. We address this problem by extending the logic with the modal ⊔ ⊓ operator (indicating necessary truth) which leads to the language λ ⊔ ⊓ Prolog. We develop a meta-interpreter realizing EBG for λ ⊔ ⊓ Prolog and give some examples in an expanded version of this extended abstract which is available as a technical report [2]. 1

We extend the Kripke-like model theory given in [10] for a fragment of firstorder hereditary Harrop formulae to include negated atoms in goals. This gives us a formal framework in which to study the role of Negation as Failure rule. The class of predicates for which Negation As Failure is applicable is discussed, as well as the predicates for which some other form of negation will need to be used. We show how the former class may be incorporated into the model theory, giving a generalisation of the usual T ! construction. No restriction on the class of programs is needed for this approach; the construction may be used for programs which are not locally stratified[14]. This is accomplished by the use of a success level and a failure level of a goal, either or both of which may be infinite. The resulting T operator is not monotonic, which necessitates a slight departure from the standard procedure, but the important properties of the construction still hold. 1 Introduction A classic ...

We enrich the domain Pos used for the static analysis of Prolog programs by combining it with types. We adopt the prescriptive view on typing, and we assume that programs are well-typed in an already existing type system. Typed static analysis of Typed Prolog programs gives access to more refined properties than untyped analysis because types give information on the inductive structure of terms that untyped static analysis does not discover. The increased refinement is not in variables assigned to true (e.g., variable recognized as bound to ground terms), but rather in variables not assigned to true; theycan be assigned a more informative value than false. For instance, the proposed analysis can show that a variable is bound to a nil-terminated list whose elements are not necessarily ground. We contend that this kind of property is sometimes more useful than groundness. Because 1 of constructors of compound types, e.g., list, the typed abstract domain can be infinite, but we show that if the so-called head-condition is satisfied by the analyzed program, then only a finite part of the domain is used. 1

We present a methodology for deriving verified programs that combines theorem proving and proof transformation steps. It extends the paradigm employed in systems like NuPrl where a program is developed and verified through the proof of the specification in a constructive type theory. We illustrate our methodology through an extended example -- a derivation of Warshall's algorithm for graph reachability. We also outline how our framework supports the definition, implementation, and use of abstract data types.

We present a logic, Lλ, in which terms are the simply typed λ-terms and very restricted, second-order quantification of functional variables is allowed. This logic can be used to directly encode the basic type judgments of a wide variety of typed λ-calculi. Judgments such as “term M is of type A ” and “M is a proof of formula A ” are represented by atomic propositions in Lλ while inference rules and axioms for such type judgments become simple quantified formulas. Theorem proving in Lλ can be described simply since the necessary unification of λ-terms is decidable and if unifiers exist, most general unifiers exist. Standard logic programming techniques can turn the specification of inference rules and axioms in Lλ into implementations of type checkers and inferrers. Several different typed λ-calculi have been specified in Lλ and these specifications have been directly executed by a higher-order logic programming language. We illustrate such encoding into Lλ by presenting type checkers and inferrers for the simply typed λ-calculus and the calculus of constructions.

Miller has shown that disjunctions are not necessary in a large fragment of hereditary Harrop formulae, a class of formulae which properly includes Horn clauses. In this paper we extend this result to include existential quantifications, so that for each program D, there is a program D 0 which is operationally equivalent, but contains no disjunctions or existential quantifications. We may think of this process as deriving a normal form for the program. This process is carried out by pushing the connectives outwards from the body of a clause, and this process leads to a normal form for goals as well. The properties of the search process used to find uniform proofs of goals (which generalises SLD-resolution) together with the normal form allow successful goals to be converted into program clauses, and so we may add successful goals to the program. The stored form of the goal requires a larger class of formulae, i.e. full first-order hereditary Harrop formulae, and so this lea...