Logic For Computable Functions Research Articles

Computational logic: its origins and applications.

Computational logic is the use of computers to establish facts in a logical formalism. Originating in nineteenth century attempts to understand the nature of mathematical reasoning, the subject now comprises a wide variety of formalisms, techniques and technologies. One strand of work follows the 'logic for computable functions (LCF) approach' pioneered by Robin Milner, where proofs can be constructed interactively or with the help of users' code (which does not compromise correctness). A refinement of LCF, called Isabelle, retains these advantages while providing flexibility in the choice of logical formalism and much stronger automation. The main application of these techniques has been to prove the correctness of hardware and software systems, but increasingly researchers have been applying them to mathematics itself.

Recent developments in mega's proof search programming language

The development of interactive tactic based theorem provers started with the LCF system [10], a system to support automated reasoning in Dana Scotts “Logic for Computable Functions”. The main idea was to base the prover on a small trusted kernel, while also allowing for ordinary user extensions without compromising soundness. For that purpose Milner designed the functional programming language ML and embedded LCF into ML. ML allowed to represent subgoaling strategies by functions, called tactics, and to combine them by higher order functions, called tacticals. By declaring an abstract type theorem with only simple inference rules type checking guaranteed that tactics decompose to primitive inference rules. While allowing for efficient execution of recorded proofs by

HOLCF = HOL + LCF

HOLCF is the definitional extension of Church's Higher-Order Logic with Scott's Logic for Computable Functions that has been implemented in the theorem prover Isabelle. This results in a flexible setup for reasoning about functional programs. HOLCF supports standard domain theory (in particular fixpoint reasoning and recursive domain equations), but also coinductive arguments about lazy datatypes. This paper describes in detail how domain theory is embedded in HOL, and presents applications from functional programming, concurrency and denotational semantics.

CALL FOR PAPERS Journal of Functional Programming Special Issue on Theorem Provers and Functional Programming

A special issue of the Journal of Functional Programming will be devoted to the use of functional programming in theorem proving. The submission deadline is 31 August 1997.The histories of theorem provers and functional languages have been deeply intertwined since the advent of Lisp. A notable example is the ML family of languages, which are named for the meta language devised for the LCF theorem prover, and which provide both the implementation platform and interaction facilities for numerous later systems (such as Coq, HOL, Isabelle, NuPrl). Other examples include Lisp (as used for ACL2, PVS, Nqthm) and Haskell (as used for Veritas).This special issue is devoted to the theory and practice of using functional languages to implement theorem provers and using theorem provers to reason about functional languages. Topics of interest include, but are not limited to:– architecture of theorem prover implementations– interface design in the functional context– limits of the LCF methodology– impact of host language features– type systems– lazy vs strict languages– imperative (impure) features– performance problems and solutions– problems of scale– special implementation techniques– term representations (e.g. de Bruijn vs name carrying vs BDDs)– limitations of current functional languages– mechanised theories of functional programming

LCF examples in HOL

The LCF theorem prover provides a logic of domain theory and is useful for reasoning about nontermination, general recursive definitions and infinite - valued datatypes like lazy lists. Because of the continued presence of bottom (undefined) elements, it is clumsy for reasoning about finite - valued datatypes and strict functions. By contrast, the HOL theorem prover provides a logic of set theory (without a notion of undefinedness) and supports reasoning about finite - valued datatypes and primitive recursive functions well. In this paper, a number of exemples are used to demonstrate that an extension of HOL with concepts of domain theory combines the best of both systems. The examples illustrate how domain and set theoretic reasoning can be mixed to advantage, allowing the full use of both. Moreover, a larger example presents a proof of correctness of the unification algorithm which shows how the painful reasoning about bottom in LCF can be eliminated.

Relationships between classes of monotonic functions

The class of monotonic (in the sense of Scott) functions is divided into subclasses of sequential and parallel ones and the problem of comparative power of different sequential and parallel functions with respect to composition (Theorems 1–5) and recursion (Theorem 6) is then investigated. In particular, Theorem 6 answers the question of Scott concerning the power of his Logic for Computable Functions.

Implementation and applications of Scott's logic for computable functions

The basis for this paper is a logic designed by Dana Scott [1] in 1969 for formalizing arguments about computable functions of higher type. This logic uses typed combinators, and we give a more or less direct translation into typed λ-calculus, which is an easier formalism to use, though not so easy for the metatheory because of the presence of bound variables. We then describe, by example only, a proof-checker program which has been implemented for this logic; the program is fully described in [2]. We relate the induction rule which is central to the logic to two more familiar rules - Recursion Induction and Structural Induction - showing that the former is a theorem of the logic, and that for recursively defined structures the latter is a derived rule of the logic. Finally we show how the syntax and semantics of a simple programming language may be described completely in the logic, and we give an example of a theorem which relates syntactic and semantic properties of programs and which can be stated and proved within the logic.

Implementation and applications of Scott's logic for computable functions

The basis for this paper is a logic designed by Dana Scott [1] in 1969 for formalizing arguments about computable functions of higher type. This logic uses typed combinators, and we give a more or less direct translation into typed λ-calculus, which is an easier formalism to use, though not so easy for the metatheory because of the presence of bound variables. We then describe, by example only, a proof-checker program which has been implemented for this logic; the program is fully described in [2]. We relate the induction rule which is central to the logic to two more familiar rules - Recursion Induction and Structural Induction - showing that the former is a theorem of the logic, and that for recursively defined structures the latter is a derived rule of the logic. Finally we show how the syntax and semantics of a simple programming language may be described completely in the logic, and we give an example of a theorem which relates syntactic and semantic properties of programs and which can be stated and proved within the logic.