15 research outputs found

    Specifying Theorem Provers in a Higher-Order Logic Programming Language

    Get PDF
    Since logic programming systems directly implement search and unification and since these operations are essential for the implementation of most theorem provers, logic programming languages should make ideal implementation languages for theorem provers. We shall argue that this is indeed the case if the logic programming language is extended in several ways. We present an extended logic programming language where first-order terms are replaced with simply-typed 位-terms, higher-order unification replaces firstorder unification, and implication and universal quantification are allowed in queries and the bodies of clauses. This language naturally specifies inference rules for various proof systems. The primitive search operations required to search for proofs generally have very simple implementations using the logical connectives of this extended logic programming language. Higher-order unification, which provides sophisticated pattern matching on formulas and proofs, can be used to determine when and at what instance an inference rule can be employed in the search for a proof. Tactics and tacticals, which provide a framework for high-level control over search, can also be directly implemented in this extended language. The theorem provers presented in this paper have been implemented in the higher-order logic programming language 位Prolog

    An Overview of Lambda-Prolog

    Get PDF
    位-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

    Deriving Mixed Evaluation from Standard Evaluation for a Simple Functional Language

    Get PDF
    We demonstrate how a specification for the standard evaluation of a simple functional programming language can be systematically extended to a specification for mixed evaluation. Using techniques inspired by natural semantics we specify a standard evaluator by a set of inference rules. The evaluation of programs is then performed by a restricted kind of theorem proving in this logic. We then describe a systematic method for extending the proof system for standard evaluation to a new proof system that provides greater flexibility in treating bound variables in the object-level functional programs. We demonstrate how this extended proof system provides the capabilities of a mixed evaluator and how correctness with respect to standard evaluation can be proved in a simple and direct manner. The current work focuses only on a primitive notion of mixed evaluation for a simple functional programming language, but we believe that our methods will extend to more sophisticated kinds of evaluations and richer languages

    Enriching a Meta-Language With Higher-Order Features

    Get PDF
    Various meta-languages for the manipulation and specification of programs and programming languages have recently been proposed. We examine one such framework, called natural semantics, which was inspired by the work of G. Plotkin on operational semantics and extended by G. Kahn and others at INRIA. Natural semantics makes use of a first-order meta-language which represents programs as first-order tree structures and reasons about these using natural deduction-like methods. We present the following three enrichments of this meta-language. First, programs are represented not by first-order structures but by simply typed 位-terms. Second, schema variables in inference rules can be higher-order variables. Third, the reasoning mechanism is explicitly extended with proof methods which have proved valuable for natural deduction systems. In particular, we add methods for introducing and discharging assumptions and for introducing and discharging parameters. The first method can be used to prove hypothetical propositions while the second can be used to prove generic or universal propositions. We provide several example specifications using this extended meta-language and compare them to their first-order specifications. We argue that our extension yields a more natural and powerful meta-language than the related first-order system. We outline how this enriched meta-language can be compiled into the higher-order logic programming language 位Prolog

    Kripke Semantics for a Logical Framework

    Get PDF
    We present a semantics (using Kripke lambda models) for a logical framework (minimal implicational predicate logic with quantification over all higher types). We apply the semantics to obtain straightforward adequacy proofs for encodings of logics in the framework. 1 Introduction There has been much recent interest in the development and use of logical frameworks. A logical framework is a formal system within which many different logics can be easily represented. It is hoped that such frameworks will facilitate the rapid development of proof assistants for the wide variety of different logics used in computer science and other fields. In this paper we give a semantic analysis (using Kripke lambda models) of the use of minimal implicational predicate logic (with quantification over all higher types) as a logical framework. We choose this framework because it is relatively straightforward to give it a useful semantics. The use of such a logic as a framework is not new. Similar logics ha..

    Abstractions in Logic Programs

    Get PDF
    Most logic programming languages have the first-order, classical theory of Horn clauses as their logical foundation. Purely proof-theoretical considerations show that Horn clauses are not rich enough to naturally provide the abstraction mechanisms that are common in most modern, general purpose programming languages. For example, Horn clauses do not incorporate the important software abstraction mechanisms of modules, data type abstractions, and higher-order programming. As a result of this lack, implementers of logic programming languages based on Horn clauses generally add several nonlogical primitives on top of Horn clauses to provide these missing abstraction mechanisms. Although the missing features are often captured in this fashion, formal semantics of the resulting languages are often lacking or are very complex. Another approach to providing these missing features is to enrich the underlying logical foundation of logic programming. This latter approach to providing logic programs with these missing abstraction mechanisms is taken in this paper. The enrichments we will consider have simple and direct operational and proof theoretical semantics

    Implementing HOL in an Higher Order Logic Programming Language

    Get PDF
    International audienceWe present a proof-of-concept prototype of a (constructive variant of an) HOL interactive theorem prover written in a Higher Order Logic Programming (HOLP) language, namely an extension of 位Prolog. The prototype is meant to support the claim, that we reinforce , that HOLP is the class of languages that provides the right abstraction level and programming primitives to obtain concise implementations of theorem provers. We identify and advocate for a programming technique, that we call semi-shallow embedding, while at the same time identifying the reasons why pure 位Prolog is not sufficient to support that technique, and it needs to be extended

    Sviluppo di un interactive theorem prover in ELPI

    Get PDF
    In questo elaborato 猫 discusso l'utilizzo del linguaggio Lambda Prolog, con interprete ELPI, per lo sviluppo di dimostratori interattivi. Nel primo capitolo viene introdotto Lambda Prolog, sono fornite indicazioni storiche sull'interactive theorem proving e descritto cosa ci si aspetta da un interactive theorem prover basato sull'isomorfismo di Curry-Howard. Le estensioni fornite da ELPI sono analizzate rispetto alla possibilit脿 di facilitare l'implementazione di un dimostratore interattivo. Nel secondo capitolo 猫 introdotta Minimalist Type Theory, analizzato il kernel implementato e su cui 猫 stato costruito il lavoro sviluppato, con una trattazione dell'implementazione di un elaboratore e di un dimostratore interattivo. Per concludere, vengono analizzati pro e contro della soluzione proposta e i suoi possibili sviluppi futuri
    corecore