42 research outputs found
NATURAL DEDUCTION AS HIGHER-ORDER RESOLUTION
An interactive theorem prover, Isabelle, is under development. In LCF, each
inference rule is represented by one function for forwards proof and another (a
tactic) for backwards proof. In Isabelle, each inference rule is represented by
a Horn clause. Resolution gives both forwards and backwards proof, supporting a
large class of logics. Isabelle has been used to prove theorems in
Martin-L\"of's Constructive Type Theory. Quantifiers pose several difficulties:
substitution, bound variables, Skolemization. Isabelle's representation of
logical syntax is the typed lambda-calculus, requiring higher- order
unification. It may have potential for logic programming. Depth-first
subgoaling along inference rules constitutes a higher-order Prolog
An Extension to ML to Handle Bound Variables in Data Structures: Preliminary Report
Most conventional programming languages have direct methods for representing first-order terms (say, via concrete datatypes in ML). If it is necessary to represent structures containing bound variables, such as 位-terms, formulas, types, or proofs, these must first be mapped into first-order terms, and then a significant number of auxiliary procedures must be implemented to manage bound variable names, check for free occurrences, do substitution, test for equality modulo alpha conversion, etc. We shall show how the applicative core of the ML programming language can be enhanced so that 位-terms can be represented more directly and so that the enhanced language, called ML位, provides a more elegant method of manipulating bound variables within data structures. In fact, the names of bound variables will not be accessible to the ML位 programmer. This extension to ML involves the following: introduction of the new type constructor \u27a =\u3e \u27b for the type of 位-terms formed by abstracting a parameter of type \u27a out of a term of type \u27b; a very restricted and simple form of higher-order pattern matching; a method for extending a given data structure with a new constructor; and, a method for extending function definitions to handle such new constructors. We present several examples of ML位 programs
Memoization-Based Proof Search in LF An Experimental Evaluation of a Prototype
AbstractElf is a general meta-language for the specification and implementation of logical systems in the style of the logical framework LF. Proof search in this framework is based on the operational semantics of logic programming. In this paper, we discuss experiments with a prototype for memoization-based proof search for Elf programs. We compare the performance of memoization-based proof search, depth-first search and iterative deepening search using two applications: 1) Bi-directional type-checker with subtyping and intersection types 2) Parsing of formulas into higher-order abstract syntax. These experiments indicate that memoization-based proof search is a practical and overall more efficient alternative to depth-first and iterative deepening search
Recommended from our members
ISABELLE - THE NEXT 700 THEOREM PROVERS
Isabelle is a generic theorem prover, designed for interactive reasoning in a
variety of formal theories. At present it provides useful proof procedures for
Constructive Type Theory, various first-order logics, Zermelo-Fraenkel set
theory, and higher-order logic. This survey of Isabelle serves as an
introduction to the literature. It explains why generic theorem proving is
beneficial. It gives a thorough history of Isabelle, beginning with its origins
in the LCF system. It presents an account of how logics are represented,
illustrated using classical logic. The approach is compared with the Edinburgh
Logical Framework. Several of the Isabelle object-logics are presented
An Overview of Lambda-Prolog
位-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
Formalising Mathematics in Simple Type Theory
Despite the considerable interest in new dependent type theories, simple type
theory (which dates from 1940) is sufficient to formalise serious topics in
mathematics. This point is seen by examining formal proofs of a theorem about
stereographic projections. A formalisation using the HOL Light proof assistant
is contrasted with one using Isabelle/HOL. Harrison's technique for formalising
Euclidean spaces is contrasted with an approach using Isabelle/HOL's axiomatic
type classes. However, every formal system can be outgrown, and mathematics
should be formalised with a view that it will eventually migrate to a new
formalism