MMT is a language, system and library (in Scala) to represent a broad range of languages in the OMDoc format: this supports formal, informal, semi-formal content. The MMT repository includes
general APIs to operate on OMDoc theories, together with various tools and applications. There are several MMT sub-projects to connect to other systems. This includes Isabelle/MMT, which appeared as preliminary version already in Nov-2018.
The release of Isabelle2019 (June 2019) is an opportunity to distribute MMT version 17.0.0 (May 2019) as Isabelle application. An alternative is to incorporate the underlying Isabelle component manually into Isabelle2019 in
$ISABELLE_HOME_USER/etc/settings like this:
init_component ".../mmt-20190611" — where the three dots refer to the directory where the component
tar.gz has been unpacked.
In either case, the
mmt.jar of the MMT distribution is included in the Isabelle/Scala package name space. The component provides Isabelle command-line tools as follows:
isabelle mmt_build to (re)build the MMT project inside the Isabelle system environment (only required after change of the Scala sources)
isabelle mmt_import to import the content of a headless Isabelle/PIDE session into MMT (OMDoc and RDF/XML triples)
isabelle mmt_server to present imported content using the built-in HTTP server of MMT
isabelle mmt to run the interactive MMT shell inside the Isabelle system environment, e.g. for experimentation within the Isabelle + MMT package namespace, using the
The main functionality is provided by
isabelle mmt_import: that is a medium-sized Scala module (57KB) within the MMT code-base (file
src/mmt-isabelle/src/info/kwarc/mmt/isabelle/Importer.scala). It refers to general export facilities of Isabelle/Scala, which are part of the Isabelle2019 distribution (file
src/Pure/Thy/export_theory.scala). The latter may be studied independently of MMT in the implementation of the
isabelle dump tool (file
src/Pure/Tools/dump.scala); see also the Isabelle System Manual, section 2.6.
The following papers provide further explanations on Isabelle/MMT:
Naproche-SAD is a recent tool by Frerix and Koepke, based on the original System for Automated Deduction (SAD) by Paskevich and others. It processes the Formal Theory Language (ForTheL), which is designed to look like mathematical text, but it is restricted to a small subset of natural language.
The tool is implemented in Haskell as a plain function from input text to output messages. A file is like a chapter of mathematical text, with a nested tree-structure of elements and sub-elements (for signatures, axiomatizations, statements, proofs). Output messages inform about the translation of mathematical text to problems of first-order logic, and indicate success or failure of external proof checking; the latter is delegated to the E Prover by Stephan Schulz and can take several seconds for each proof obligation.
To integrate Naproche-SAD into PIDE, Frerix and Wenzel have reworked the Haskell program over 2 months in 2018, to turn the command-line tool into a service for reactive checking of ForTheL texts. Isabelle integration was done via the new Isabelle/Haskell library and some glue code in Isabelle/Scala to register ForTheL as auxiliary file-format (extension
The resulting Isabelle/Naproche application is available as multi-platform download. A running instance is shown in the screenshot: users can directly open ForTheL files (e.g. from
Examples) and wait briefly to see output messages attached to the text in the usual IDE manner. Further edits produce a new version of the text, which is sent in total to Naproche-SAD again. The back-end is sufficiently smart to avoid redundant checking of unchanged sub-elements: it keeps a global state with results of old versions: this is easy to implement as the program keeps running until shutdown of Isabelle/PIDE.
(Cited from section 1.2 of the paper Interaction with Formal Mathematical Documents in Isabelle/PIDE.)
During the two weeks of 17..28-Jun-2019, I will be visiting Deducteam at LSV, Paris/Cachan. There will be two presentations about Isabelle technology for formal documents and libraries:
- Interaction with Formal Mathematical Documents in Isabelle/PIDE (with slides) – Tuesday 18-Jun-2019, 11:00, Pavillon du Jardin, ENS Cachan.
- Isabelle technology for the Archive of Formal Proofs (with slides) – Thursday 20-Jun-2019, 14:00, LSV library.
See also the official announcement of Deducteam.
Note: These talks will be repeated at the Conference on Intelligent Computer Mathematics (CICM 2019), Prague (CZ), 08..12-Jul-2019.
At the Conference for Intelligent Computer Mathematics (CICM 2019) in Prague (08..12-Jul-2019), I will give a keynote presentation on the track Mathematical Knowledge Management (MKM).
- Interaction with Formal Mathematical Documents in Isabelle/PIDE
- Isabelle/PIDE has emerged over more than 10 years as the standard Prover IDE for interactive theorem proving in Isabelle. The well-established Archive of Formal Proofs (AFP) testifies the success of such applications of formalized mathematics in Isabelle/HOL. More recently, the scope of PIDE has widened towards languages that are not connected to logic and proof in Isabelle, but taken from a broader repertoire of mathematics on the computer. The present paper provides a general overview of the PIDE project and its underlying document model, with built-in parallel evaluation and asynchronous interaction. There is also some discussion of original aims and approaches, successes and failures, later changes to the plan, and ideas for the future.
- Preprint from ArXiv
The kernel update
linux-image-4.15.0-36-generic (Oct-2018) introduces a timing problem with socket communication in the Isabelle Prover IDE, notably Isabelle/jEdit. Thus loading big sessions becomes very slow (e.g. theory
This can be avoided by downgrading to
linux-image-4.15.0-34-generic or by using the following temporary workaround for Isabelle2018.
At the Dagstuhl-Seminar 18341 Formalization of Mathematics in Type Theory (19..24-Aug-2018), I delivered a talk on The Isabelle Prover IDE after 10 years of development.
The main ideas around Isabelle/PIDE go back to summer 2008. This is an overview of what has been achieved in the past 10 years, with some prospects for the future. Where can we go from here as Isabelle community? (E.g. towards alternative front-ends like Visual Studio Code; remote prover sessions “in the cloud”; support for collaborative editing of large formal libraries.) Where can we go as greater ITP community (Lean, Coq, HOL family)?
See also the slides.
In the discussion after the talk, there was a very fitting reference to the website of Bret Victor, “perveyor of impossible dreams”.
Here is the video for my presentation at Curry Club Augsburg (09-Aug-2018) about Isabelle/VSCode and the Language Server Protocol:
The PDF Slides (including important links) are also available.
Here is the video for the Isabelle/PIDE presentation at Curry Club Augsburg from 14-Jun-2018:
There are some technical challenges: missing screen recording in the first 25min, and occasional changes in the speed of screen recording later on: sometimes the computer screen is ahead of the talk. Nonetheless, this is an opportunity to learn many things about Isabelle/PIDE, how it is done, why it is done like that.
On Thu 14-Jun-2018 I will talk about Isabelle/jEdit as Formal IDE at Curry Club Augsburg.
Start: approximately 19:00.
Language of the talk: German
This is a spin-off from the paper that I will present at the F-IDE workshop on Sat 14-Jul-2018 in Oxford.
This is my contribution to the F-IDE workshop (14-Jul-2018, Oxford, UK): Isabelle/jEdit as IDE for domain-specific formal languages and informal text documents.
Isabelle/jEdit is the main application of the Prover IDE (PIDE) framework and the default user-interface of Isabelle, but it is not limited to theorem proving. This paper explores possibilities to use it as a general IDE for formal languages that are defined in user-space, and embedded into informal text documents. It covers overall document structure with auxiliary files and document antiquotations, formal text delimiters and markers for interpretation (via control symbols). The ultimate question behind this: How far can we stretch a plain text editor like jEdit in order to support semantic text processing, with support by the underlying PIDE framework?
See also the official slides.