Introduction to Isabelle (original) (raw)
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.
Isabelle: the next 700 theorem provers
The theorem prover Isabelle is described briefly and informally. Its historical development is traced from Edinburgh LCF to the present day. The main issues are unification, quantifiers, and the representation of inference rules. The Edinburgh Logical Framework is also described, for a comparison with Isabelle. An appendix presents several Isabelle logics, including set theory and Constructive Type Theory, with examples of theorems.
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.
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.
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].
An Axiomatic Value Model for Isabelle/UTP
Lecture Notes in Computer Science, 2017
The Unifying Theories of Programming (UTP) is a mathematical framework to define, examine and link program semantics for a large variety of computational paradigms. Several mechanisations of the UTP in HOL theorem provers have been developed. All of them, however, succumb to a trade off in how they encode the value model of UTP theories. A deep and unified value model via a universal (data)type incurs restrictions on permissible value types and adds complexity; a value model directly instantiating HOL types for UTP values retains simplicity, but sacrifices expressiveness, since we lose the ability to compositionally reason about alphabets and theories. We here propose an alternative solution that axiomatises the value model and retains the advantages of both approaches. We carefully craft a definitional mechanism in the Isabelle/HOL prover that guarantees soundness.
Structured Formal Development in Isabelle
Nordic Journal of Computing - NJC, 2006
General purpose theorem provers provide advanced facilities for proving prop- erties about specifications, and may therefore be a valuable tool in formal program devel- opment. However, these provers generally lack many of the useful structuring mechanisms found in functional programming or specification languages. This paper presents a con- structive approach to adding theory morphisms and parametrisation to theorem provers, while preserving the proof support and consistency of the prover. The approach is im- plemented in Isabelle and illustrated by examples of an algorithm design rule and of the modular development of computational e ects for imperative language features based on monads.
From Types to Sets by Local Type Definition in Higher-Order Logic
Journal of Automated Reasoning
Types in higher-order logic (HOL) are naturally interpreted as nonempty sets. This intuition is reflected in the type definition rule for the HOL-based systems (including Isabelle/HOL), where a new type can be defined whenever a nonempty set is exhibited. However, in HOL this definition mechanism cannot be applied inside proof contexts. We propose a more expressive type definition rule that addresses the limitation and we prove its consistency. This higher expressive power opens the opportunity for a HOL tool that relativizes type-based statements to more flexible set-based variants in a principled way. We also address particularities of Isabelle/HOL and show how to perform the relativization in the presence of type classes.
2012 27th Annual IEEE Symposium on Logic in Computer Science, 2012
Interactive theorem provers based on higher-order logic (HOL) traditionally follow the definitional approach, reducing high-level specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in HOL4, HOL Light, and Isabelle/ HOL is fundamentally noncompositional, limiting its efficiency and flexibility, and it does not cater for codatatypes.
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 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 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.
Focus on Isabelle: From Specification to Verification
2008
This approach introduces a coupling of a specification framework with a verification system. Given a system, represented in a formal specification framework, one can verify its properties by translating the specification to a Higher-Order Logic and subsequently using the theorem prover Isabelle/HOL or the point of disagreement will be found. Moreover, using this approach one can validate the refinement relation between two given systems, as well as make automatic correctness proofs of syntactic interfaces for specified system components. The approach uses particularly the idea of refinement-based verification, where a verification of system properties can be treated as a validation of a system specification with respect to the specification of the properties.
A Type-Theoretic Framework for Formal Reasoning with Different Logical Foundations
Lecture Notes in Computer Science, 2007
A type-theoretic framework for formal reasoning with different logical foundations is introduced and studied. With logic-enriched type theories formulated in a logical framework, it allows various logical systems such as classical logic as well as intuitionistic logic to be used effectively alongside inductive data types and type universes. This provides an adequate basis for wider applications of type theory based theorem proving technology. Two notions of set are introduced in the framework and used in two case studies of classical reasoning: a predicative one in the formalisation of Weyl's predicative mathematics and an impredicative one in the verification of security protocols.
A Mechanised Proof of Gödel’s Incompleteness Theorems using Nominal Isabelle
A Isabelle/HOL formalisation of Gödel's two incompleteness theorems is presented. Aspects of the development are described in detail, including two separate treatments of variable binding: the nominal package [25] and de Bruijn indices [3]. The work followsŚwierczkowski's a detailed proof, using hereditarily finite set theory [23].
In this paper we discuss the similarities between program specialisation and inductive theorem proving, and then show how program specialisation can be used to perform inductive theorem proving. We then study this relationship in more detail for the particular problem of verifying infinite state systems in order to establish a clear link between program specialisation and inductive theorem proving. Indeed, Ecce is a program specialisation system which can be used to automatically generate abstractions for the model checking of infinite state systems. We show that to verify the abstractions generated by Ecce we may employ the proof assistant Isabelle. Thereby Ecce is used to generate the specification, hypotheses and proof script in Isabelle's theory format. Then, in many cases, Isabelle can automatically execute these proof scripts and thereby verify the soundness of Ecce's abstraction. In this work we focus on the specification and verification of Petri nets.