Isabelle (proof assistant)

The Isabelle automated theorem prover is a higher-order logic (HOL) theorem prover, written in Standard ML and Scala.

Uses your system voice; voice and rate in settings.

Snapshot

≈ 4 min read

Names in other languages

No names in other languages are held for this entry yet.

Article bodies are English and are not machine-translated. A name in another language is not a translation of the article.

The Isabelle automated theorem prover is a higher-order logic (HOL) theorem prover, written in Standard ML and Scala. As a Logic for Computable Functions (LCF) style theorem prover, it is based on a small logical core (kernel) to increase the trustworthiness of proofs without requiring, yet supporting, explicit proof objects.

Isabelle is available inside a flexible system framework allowing for logically safe extensions, which comprise both theories and implementations for code-generating, documenting, and specific support for a variety of formal methods. It can be seen as an integrated development environment (IDE) for formal methods.

In recent years, a substantial number of theories and system extensions have been collected in the Isabelle Archive of Formal Proofs (Isabelle AFP). Isabelle was named by Lawrence Paulson after Gérard Huet's daughter. The Isabelle theorem prover is free software, released under the revised BSD license.

Example proof

Isabelle allows proofs to be written in two different styles, the procedural and the declarative. Procedural proofs specify a series of tactics (theorem proving functions/procedures) to apply. While reflecting the procedure that a human mathematician might apply to proving a result, they are typically hard to read as they do not describe the outcome of these steps.

This style is "considered harmful" in the Isabelle documentation. On the other hand, declarative proofs (supported by Isabelle's proof language, Isar) specify the actual mathematical operations to be performed, and are therefore more easily read and checked by humans.

For example, a declarative proof by contradiction in Isar that the square root of two is not rational can be written as follows. sqrt2_not_rational: ?x = m n :: nat sqrt_rat: lowest_terms: (rule Rats_abs_nat_div_natE) (auto simp add: power2_eq_square) eq: of_nat_eq_iff power2_eq_square fastforce simp simp - k .. eq simp simp simp (rule gcd_greatest) lowest_terms simp False odd_one blast

Applications

Isabelle has been used to aid formal methods for the specification, development and verification of software and hardware systems. Isabelle has been used to formalize numerous theorems from mathematics and computer science, like Gödel's completeness theorem, Gödel's theorem about the consistency of the axiom of choice, the prime number theorem, correctness of security protocols, and properties of programming language semantics.

Many of the formal proofs are, as mentioned, maintained in the Archive of Formal Proofs, which contains (as of 2019) at least 500 articles with over 2 million lines of proof in total. In 2009, the L4.verified project at NICTA produced the first formal proof of functional correctness of a general-purpose operating system kernel: the seL4 (secure embedded L4) microkernel.

The proof is constructed and checked in Isabelle/HOL and comprises over 200,000 lines of proof script to verify 7,500 lines of C. The verification covers code, design, and implementation, and the main theorem states that the C code correctly implements the formal specification of the kernel. The proof uncovered 144 bugs in an early version of the C code of the seL4 kernel, and about 150 issues in each of design and specification.

The definition of the programming language Lightweight Java was proven type-sound in Isabelle.

Alternatives

Several languages and systems provide similar functions: Agda, written in Haskell Rocq (formerly named Coq), written in OCaml Lean, written in Lean and C++ LEGO, written in Standard ML of New Jersey Mizar system, written in Free Pascal Metamath, written in ANSI C Prover9, written in C, with a GUI written in Python Twelf, written in Standard ML

Further reading

Lawrence C. Paulson, "The Foundation of a Generic Theorem Prover", Journal of Automated Reasoning, Volume 5, Issue 3 (September 1989), pages: 363–397, . Lawrence C. Paulson and Tobias Nipkow, "Isabelle Tutorial and User's Manual", 1990.

M. A. Ozols, K. A. Eastaughffe, and A. Cant, "DOVE: A Tool for Design Oriented Verification and Evaluation", Proceedings of AMAST 97, M. Johnson, editor, Sydney, Australia. Lecture Notes in Computer Science (LNCS) Vol. 1349, Springer Verlag, 1997. Tobias Nipkow, Lawrence C. Paulson, Markus Wenzel, "Isabelle/HOL – A Proof Assistant for Higher-Order Logic", 2020.

Isabelle on Stack Overflow The Archive of Formal Proofs IsarMathLib

Text derived from https://en.wikipedia.org/w/index.php?oldid=1375698912 under CC BY-SA 4.0; modifications have been made.

Sources cited in this revision

8 named source(s) extracted from the cited revision. A source with no author is shown by its publication; nothing is invented.