Isabelle

[Isabelle logo]

Isabelle is a popular generic theorem proving environment developed at Cambridge University (Larry Paulson) and TU Munich (Tobias Nipkow). The latest version is Isabelle98-1. It is available from several mirror sites.

Isabelle can be viewed from two main perspectives. On the one hand it may serve as a generic framework for rapid prototyping of deductive systems. On the other hand, major object logics like Isabelle/HOL provide a theorem proving environment ready to use for sizable applications.

Object logics

The Isabelle distribution includes a large body of object logics and other examples (see the Isabelle theory library).
Isabelle/HOL
is a version of classical higher-order logic, similar to Gordon's HOL (it is related to Church's Simple Theory of Types).
Isabelle/HOLCF
adds a considerably amount of Scott's domain theory to HOL.
Isabelle/FOL
provides basic classical and intuitionistic first-order (polymorphic) logic.
Isabelle/ZF
offers a formulation of Zermelo-Fraenkel set theory on top of FOL.

Isabelle/HOL is currently the best developed 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.). The distribution also includes some large applications, for example correctness proofs of cryptographic protocols (HOL/Auth).

Isabelle/ZF provides another starting point for applications, with a slightly less developed library, though. Its definitional packages are similar to those of Isabelle/HOL. Untyped ZF provides more advanced constructions for sets than simply typed HOL.

There are also a few minor object logics that may serve as further examples: CTT is an extensional version of Martin-Löf's Type Theory, Cube is Barendregt's Lambda Cube. There are also some sequent calculus examples under Sequents, including modal or linear logics. Again see the Isabelle theory library for other examples.

Defining Logics

Logics are not hard-wired into Isabelle, but formulated within Isabelle's meta logic: Isabelle/Pure. There are quite a lot of syntactic and deductive tools available in generic Isabelle. Thus defining new logics or extending existing ones basically works as follows:
  1. declare concrete syntax (via mixfix grammar and syntax macros),
  2. declare abstract syntax (as higher-order constants),
  3. declare inference rules (as meta-logical propositions),
  4. instantiate generic proof tools (simplifier, classical tableau prover etc.),
  5. manually code special proof procedures (via tacticals or hand-written ML).
The first 3 steps above are fully declarative and involve no ML programming at all. Thus one already gets a decent deductive environment based on primitive inferences (by employing the built-in mechanisms of Isabelle/Pure, in particular higher-order unification and resolution). For sizable applications some degree of automated reasoning is essential. Instantiating existing tools like the classical tableau prover involves only minimal ML-based setup. One may also write arbitrary proof procedures or even theory extension packages in ML, without breaching system soundness (Isabelle follows the well-known LCF system approach to achieve a secure system).

Further information

[Cambridge] [Munich] The local Isabelle pages at Cambridge and Munich provide further information on Isabelle and related projects.