Isabelle: the next 700 theorem provers (original) (raw)
Related papers
Applications of Proof Theory to Isabelle
1996
Abstract Isabelle [3, 4] is a generic theorem prover. It suppports interactive proof in several formal systems, including first-order logic (intuitionistic and classical), higher-order logic, Martin-Löf type theory, and Zermelo-Fraenkel set theory. New logics can be introduced by specifying their syntax and rules of inference. Both natural deduction and sequent calculi are allowed.
i Preface Isabelle [10,] is a generic theorem prover. It has been instantiated to support reasoning in several object-logics:
The Foundation of a Generic Theorem Prover
2000
Isabelle is an interactive theorem prover that supports a variety of logics. It represents rules as propositions (not as functions) and builds proofs by combining rules. These operations constitute a meta-logic (or 'logical framework') in which the object-logics are formalized. Isabelle is now based on higher-order logic -a precise and well-understood foundation.
1999
Several logics come with Isabelle. Many of them are sufficiently developed to serve as comfortable reasoning environments. They are also good starting points for defining new logics. Each logic is distributed with sample proofs, some of which are described in this document. HOL is currently the best developed Isabelle object-logic, including an extensive library of (concrete) mathematics, and various packages for advanced definitional concepts (like (co-) inductive sets and types, well-founded recursion etc.).
2008
Isabelle, which is available from http://isabelle. in. tum. de, is a generic framework for interactive theorem proving. The Isabelle/Pure meta-logic allows the formalization of the syntax and inference rules of a broad range of object-logics following the general idea of natural deduction [32, 33]. The logical core is implemented according to the well-known “LCF approach” of secure inferences as abstract datatype constructors in ML [16]; explicit proof terms are also available [8].
A Consistent Foundation for Isabelle/HOL
Lecture Notes in Computer Science, 2015
The interactive theorem prover Isabelle/HOL is based on the well understood Higher-Order Logic (HOL), which is widely believed to be consistent (and provably consistent in set theory by a standard semantic argument). However, Isabelle/HOL brings its own personal touch to HOL: overloaded constant definitions, used to achieve Haskell-like type classes in the user space. These features are a delight for the users, but unfortunately are not easy to get right as an extension of HOL-they have a history of inconsistent behavior. It has been an open question under which criteria overloaded constant definitions and type definitions can be combined together while still guaranteeing consistency. This paper presents a solution to this problem: non-overlapping definitions and termination of the definition-dependency relation (tracked not only through constants but also through types) ensures relative consistency of Isabelle/HOL.
A Preliminary User's Manual for Isabelle
The theorem prover Isabelle and several of its object-logics are described. Where other papers have been concerned with theory, the emphasis here is completely practical: the operations, commands, data structures, and organization of Isabelle. This information could benefit both users of Isabelle and implementors of other systems.
A Generic Theorem Prover Construction Framework
Formal software engineering methodologies provide a vast array of languages for specifying correctness properties and associated tools for property verification. Unfortunately, the implementation of each verification tool requires an early commitment to a particular methodology and language, in terms of both high-level semantic concerns and low-level syntactic representation of properties and proofs. In this paper, we present Prufrock, a novel approach to constructing automated reasoning systems, which abstracts semantic concerns over entire classes of potential object languages. Prufrock is a modular, generic prover framework written in Haskell taking advantage of its type class system. It consists of a set of independent logic modules defining the semantics required for proof over entire classes of abstract syntaxes using generic programming techniques. The fundamental contribution of Prufrock is that any object language may be used for specifying and verifying properties, as long as it provides a semantics consistent with the logic modules required for a proof. The implementation details of the reasoning system thus remain independent from the structure of the specification language. This facilitates large-scale reuse of logics as well as tacticals and proofs themselves when constructing or retargeting automated reasoning tools. At the same time, Prufrock aids in closing the gap between an object language and verification of objects written in it by operating on its abstract syntax directly rather than transforming it into a separate theorem proving language. * This material is based upon work supported by the United States National Science Foundation under Grant Nos. 0209193 and 0350425 † This work was completed while a student in the System-Level Design Group at The University of Kansas properties, and axioms used in the verification process. Inference and proof are carried out by manipulating this syntax in a logically sound fashion. Unfortunately, this approach can be a serious hindrance to modularity and reuse due to the tight coupling between abstract syntax and the proof techniques used to manipulate it.
A Generic Tableau Prover and its Integration with Isabelle
A generic tableau prover has been implemented and integrated with Isa- belle (Paulson, 1994). Compared with classical first-order logic provers, it has numerous extensions that allow it to reason with any supplied set of tableau rules. It has a higher- order syntax in order to support user-defined binding operators, such as those of set theory. The unification algorithm is first-order instead of higher-order, but it includes modifications to handle bound variables. The proof, when found, is returned to Isabelle as a list of tactics. Because Isabelle verifies the proof, the prover can cut corners for efficiency’s sake without compromis- ing soundness. For example, the prover can use type information to guide the search without storing type information in full.