Introduction to Isabelle

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].

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.

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.

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.

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.

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.

… on Theorem Proving in Higher Order …, 2001

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.

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.