15 research outputs found
Asynchronous processing of Coq documents: from the kernel up to the user interface
The work described in this paper improves the reactivity of the Coq system by
completely redesigning the way it processes a formal document. By subdividing
such work into independent tasks the system can give precedence to the ones of
immediate interest for the user and postpones the others. On the user side, a
modern interface based on the PIDE middleware aggregates and present in a
consistent way the output of the prover. Finally postponed tasks are processed
exploiting modern, parallel, hardware to offer better scalability.Comment: in Proceedings of ITP, Aug 2015, Nanjing, Chin
PIDE for Asynchronous Interaction with Coq
This paper describes the initial progress towards integrating the Coq proof
assistant with the PIDE architecture initially developed for Isabelle. The
architecture is aimed at asynchronous, parallel interaction with proof
assistants, and is tied in heavily with a plugin that allows the jEdit editor
to work with Isabelle.
We have made some generalizations to the PIDE architecture to accommodate for
more provers than just Isabelle, and adapted Coq to understand the core
protocol: this delivered a working system in about two man-months.Comment: In Proceedings UITP 2014, arXiv:1410.785
Isabelle/DOF: Design and Implementation
This is the author accepted manuscript. The final version is available from Springer Verlag via the DOI in this record17th International Conference, SEFM 2019
Oslo, Norway, September 18–20, 2019DOF is a novel framework for defining ontologies and enforcing them during document development and evolution. A major goal of DOF is the integrated development of formal certification documents (e. g., for Common Criteria or CENELEC 50128) that require consistency across both formal and informal arguments. To support a consistent development of formal and informal parts of a document, we provide Isabelle/DOF, an implementation of DOF on top of the formal methods framework Isabelle/HOL. A particular emphasis is put on a deep integration into Isabelleâs IDE, which allows for smooth ontology development as well as immediate ontological feedback during the editing of a document. In this paper, we give an in-depth presentation of the design concepts of DOFâs Ontology Definition Language (ODL) and key aspects of the technology of its implementation. Isabelle/DOF is the first ontology language supporting machine-checked links between the formal and informal parts in an LCF-style interactive theorem proving environment. Sufficiently annotated, large documents can easily be developed collabo- ratively, while ensuring their consistency, and the impact of changes (in the formal and the semi-formal content) is tracked automatically.IRT SystemX, Paris-Saclay, Franc
Translating Scala Programs to Isabelle/HOL, Automated Reasoning
We present a trustworthy connection between the Leon verification system and the Isabelle proof assistant. Leon is a system for verifying functional Scala programs. It uses a variety of automated theorem provers (ATPs) to check verification conditions (VCs) stemming from the input program. Isabelle, on the other hand, is an interactive theorem prover used to verify mathematical specifications using its own input language Isabelle/Isar. Users specify (inductive) definitions and write proofs about them manually, albeit with the help of semi-automated tactics. The integration of these two systems allows us to exploit Isabelle’s rich standard library and give greater confidence guarantees in the correctness of analysed programs
Deeply Integrating C11 Code Support into Isabelle/PIDE
We present a framework for C code in C11 syntax deeply integrated into the
Isabelle/PIDE development environment. Our framework provides an abstract
interface for verification back-ends to be plugged-in independently. Thus,
various techniques such as deductive program verification or white-box testing
can be applied to the same source, which is part of an integrated PIDE document
model. Semantic back-ends are free to choose the supported C fragment and its
semantics. In particular, they can differ on the chosen memory model or the
specification mechanism for framing conditions.
Our framework supports semantic annotations of C sources in the form of
comments. Annotations serve to locally control back-end settings, and can
express the term focus to which an annotation refers. Both the logical and the
syntactic context are available when semantic annotations are evaluated. As a
consequence, a formula in an annotation can refer both to HOL or C variables.
Our approach demonstrates the degree of maturity and expressive power the
Isabelle/PIDE subsystem has achieved in recent years. Our integration technique
employs Lex and Yacc style grammars to ensure efficient deterministic parsing.
We present two case studies for the integration of (known) semantic back-ends
in order to validate the design decisions for our back-end interface.Comment: In Proceedings F-IDE 2019, arXiv:1912.0961
Virtualization of HOL4 in Isabelle
We present a novel approach to combine the HOL4 and Isabelle theorem provers: both are implemented in SML and based on distinctive variants of HOL. The design of HOL4 allows to replace its inference kernel modules, and the system infrastructure of Isabelle allows to embed other applications of SML. That is the starting point to provide a virtual instance of HOL4 in the same run-time environment as Isabelle. Moreover, with an implementation of a virtual HOL4 kernel that operates on Isabelle/HOL terms and theorems, we can load substantial HOL4 libraries to make them Isabelle theories, but still disconnected from existing Isabelle content. Finally, we introduce a methodology based on the transfer package of Isabelle to connect the imported HOL4 material to that of Isabelle/HOL
An Extensible User Interface for Lean 4
Contemporary proof assistants rely on complex automation and process libraries with millions of lines of code. At these scales, understanding the emergent interactions between components can be a serious challenge. One way of managing complexity, long established in informal practice, is through varying external representations. For instance, algebraic notation facilitates term-based reasoning whereas geometric diagrams invoke spatial intuition. Objects viewed one way become much simpler than when viewed differently. In contrast, modern general-purpose ITP systems usually only support limited, textual representations. Treating this as a problem of human-computer interaction, we aim to demonstrate that presentations - UI elements that store references to the objects they are displaying - are a fruitful way of thinking about ITP interface design. They allow us to make headway on two fronts - introspection of prover internals and support for diagrammatic reasoning. To this end we have built an extensible user interface for the Lean 4 prover with an associated ProofWidgets 4 library of presentation-based UI components. We demonstrate the system with several examples including type information popups, structured traces, contextual suggestions, a display for algebraic reasoning, and visualizations of red-black trees. Our interface is already part of the core Lean distribution