Abstract We have definitionally extended Isabelle/HOLCF to support axiomatic Haskell-style constructor classes. We have subsequently defined the functor and monad classes, together with their laws, and implemented state and resumption monad transformers as generic constructor class instances. This is a step towards our goal of giving modular denotational semantics for concurrent lazy functional programming languages, such as GHC Haskell. 1

We present an approach to mathematical assistants which uses readable, executable proof scripts as the central language for interaction. We examine an implementation that combines the Isar language, the Isabelle theorem prover and the IsaPlanner proof planner. We argue that this synergy provides a flexible environment for the exploration, certification, and presentation of mathematical proof.

This paper argues that a pragmatic approach is needed for integrating design and formalisation of complex systems. We report on our approach to designing the seL4 operating system microkernel API and its formalisation in Isabelle/HOL. The formalisation consists of the systematic translation of significant parts of the functional programming language Haskell into Isabelle/HOL, including monadbased code. We give an account of the experience, decisions and outcomes in this translation as well as the technical problems we encountered together with our solutions. The longer-term goal is to demonstrate that formalisation and verification of a large, complex, OS-level code base is feasible with current tools and methods and is in the order of magnitude of traditional development cost.

Automated proof assistants provide few facilities for incremental development. Generally, if the underlying structures on which a proof is based are modified, the developer must redo much of the proof. Yet incremental development is really the most natural approach for proofs of programming language properties [5, 12]. We propose “proof weaving”, a technique that allows a proof developer to combine small proofs into larger ones by merging proof objects. We automate much of the merging process and thus ease incremental proof development for programming language properties. To make the discussion concrete we take as an example the problem of proving typesoundness by proving progress and preservation [17] in Coq [3, 7]. However we believe that the methods can be generalized to other proof assistants which generate proof objects, and most directly to those proof assistants which exploit the Curry-Howard isomorphism in representing proof terms as λ-terms [16], e.g. Isabelle and Minlog. We rely on the proof developer to initially prove type-soundness for “tiny ” languages. Each of these languages encapsulates a single well-defined programming feature. For example, a tiny language of booleans can be restricted to the terms True, False, and If and their

Modern integrated development environments (IDEs) provide programmers with a variety of sophisticated tools for program visualization and manipulation. These tools assist the programmer in understanding legacy code and making coordinated changes across large parts of a program. Similar tools incorporated into an integrated proof environment (IPE) would assist proof developers in understanding and manipulating the increasingly larger proofs that are being developed. In this paper we propose some tools and techniques developed for software engineering that we believe would be equally applicable in proof engineering.

Abstract. In this work we present proof terms for a Gentzen sequent style presentation of HOL. Existing implementations of proof terms for HOL are natural deduction style systems. Sequent style proof terms have many advantages over natural deduction style proof terms. For example, we can translate proof terms directly into tactics, which we can execute at the tactic level of HOL implementations. We describe several applications of our work, such as an implementation of theory interpretation, and an approach to optimising proof terms by rewriting. 1

Abstract not found