Results 1  10
of
12
Foundational, Compositional (Co)datatypes for HigherOrder Logic  Category Theory Applied to Theorem Proving
"... Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in H ..."
Abstract

Cited by 16 (10 self)
 Add to MetaCart
(Show Context)
Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in HOL4, HOL Light, and Isabelle/HOL is fundamentally noncompositional, limiting its efficiency and flexibility, and it does not cater for codatatypes. We present a fully modular framework for constructing (co)datatypes in HOL, with support for mixed mutual and nested (co)recursion. Mixed (co)recursion enables type definitions involving both datatypes and codatatypes, such as the type of finitely branching trees of possibly infinite depth. Our framework draws heavily from category theory. The key notion is that of a rich type constructor—a functor satisfying specific properties preserved by interesting categorical operations. Our ideas are formalized in Isabelle and implemented as a new definitional package, answering a longstanding user request.
Formal verification of monad transformers
 In ICFP’12
, 2012
"... We present techniques for reasoning about constructor classes that (like the monad class) fix polymorphic operations and assert polymorphic axioms. We do not require a logic with firstclass type constructors, firstclass polymorphism, or type quantification; instead, we rely on a domaintheoretic m ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
(Show Context)
We present techniques for reasoning about constructor classes that (like the monad class) fix polymorphic operations and assert polymorphic axioms. We do not require a logic with firstclass type constructors, firstclass polymorphism, or type quantification; instead, we rely on a domaintheoretic model of the type system in a universal domain to provide these features. These ideas are implemented in the Tycon library for the Isabelle theorem prover, which builds on the HOLCF library of domain theory. The Tycon library provides various axiomatic type constructor classes, including functors and monads. It also provides automation for instantiating those classes, and for defining further subclasses. We use the Tycon library to formalize three Haskell monad transformers: the error transformer, the writer transformer, and the resumption transformer. The error and writer transformers do not universally preserve the monad laws; however, we establish datatype invariants for each, showing that they are valid monads when viewed as abstract datatypes.
Data Refinement in Isabelle/HOL
"... Abstract. The paper shows how the code generator of Isabelle/HOL supports data refinement, i.e., providing efficient code for operations on abstract types, e.g., sets or numbers. This allows all tools that employ code generation, e.g., Quickcheck or proof by evaluation, to compute with these abstrac ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
Abstract. The paper shows how the code generator of Isabelle/HOL supports data refinement, i.e., providing efficient code for operations on abstract types, e.g., sets or numbers. This allows all tools that employ code generation, e.g., Quickcheck or proof by evaluation, to compute with these abstract types. At the core is an extension of the code generator to deal with data type invariants. In order to automate the process of setting up specific data refinements, two packages for transferring definitions and theorems between types are exploited. 1
General Bindings and AlphaEquivalence in Nominal Isabelle
"... Abstract. Nominal Isabelle is a definitional extension of the Isabelle/HOL theorem prover. It provides a proving infrastructure for reasoning about programming language calculi involving named bound variables (as opposed to deBruijn indices). In this paper we present an extension of Nominal Isabell ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Nominal Isabelle is a definitional extension of the Isabelle/HOL theorem prover. It provides a proving infrastructure for reasoning about programming language calculi involving named bound variables (as opposed to deBruijn indices). In this paper we present an extension of Nominal Isabelle for dealing with general bindings, that means termconstructors where multiple variables are bound at once. Such general bindings are ubiquitous in programming language research and only very poorly supported with single binders, such as lambdaabstractions. Our extension includes new definitions of αequivalence and establishes automatically the reasoning infrastructure for αequated terms. We also prove strong induction principles that have the usual variable convention already built in. 1
Witnessing (Co)datatypes
"... Abstract. Datatypes and codatatypes are very useful for specifying and reasoning about (possibly infinite) computational processes. The interactive theorem prover Isabelle/HOL has been extended with a definitional package that supports both. Here we describe a complete procedure for deriving nonempt ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
Abstract. Datatypes and codatatypes are very useful for specifying and reasoning about (possibly infinite) computational processes. The interactive theorem prover Isabelle/HOL has been extended with a definitional package that supports both. Here we describe a complete procedure for deriving nonemptiness witnesses in the general mutually recursive, nested case—nonemptiness being a proviso for introducing new types in higherorder logic. The nonemptiness problem also provides an illuminating case study that shows the package in action, tracing its journey from abstract category theory to handson functionality. 1
A.: Nonfree datatypes in Isabelle/HOL: Animating a manysorted metatheory
 CPP 2013. LNCS
, 2013
"... Abstract. Datatypes freely generated by their constructors are well supported in mainstream proof assistants. Algebraic specification languages offer more expressive datatypes on axiomatic means: nonfree datatypes generated from constructors modulo equations. We have implemented an Isabelle/HOL pa ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Datatypes freely generated by their constructors are well supported in mainstream proof assistants. Algebraic specification languages offer more expressive datatypes on axiomatic means: nonfree datatypes generated from constructors modulo equations. We have implemented an Isabelle/HOL package for nonfree datatypes, without compromising foundations. The use of the package, and its nonfree iterator in particular, is illustrated with examples: bags, polynomials and λterms modulo αequivalence. The manysorted metatheory of nonfree datatypes is formalized as an ordinary Isabelle theory and is animated by the package into userspecified instances. HOL lacks a type of types, so we employ an ad hoc construction of a universe embedding the relevant parameter types. 1
A category theory based (co)datatype package . . .
, 2012
"... Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Higherorder logic (HOL) forms the basis of several popular interactive theorem provers. These follow the definitional approach, reducing highlevel specifications to logical primitives. This also applies to the support for datatype definitions. However, the internal datatype construction used in HOL4, HOL Light and Isabelle/HOL is fundamentally noncompositional, limiting its efficiency and flexibility, and it does not cater for codatatypes. We present a fully modular framework for constructing (co)datatypes in HOL, with support for mixed mutual and nested (co)recursion. Mixed (co)recursion enables type definitions involving both datatypes and codatatypes, such as the type of finitely branching trees of possibly infinite depth. Our framework draws heavily from category theory. The key notion is that of a bounded natural functor—a functor satisfying specific properties preserved by interesting categorical operations. Our ideas are formalized in Isabelle and implemented as a new definitional package, answering a longstanding user request.
Unified decision procedures for regular expression equivalence. http://www.in.tum.de/∼nipkow/pubs/regex equiv. pdf
, 2014
"... Abstract. We formalize a unified framework for verified decision procedures for regular expression equivalence. Five recently published formalizations of such decision procedures (three based on derivatives, two on marked regular expressions) can be obtained as instances of the framework. We discov ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We formalize a unified framework for verified decision procedures for regular expression equivalence. Five recently published formalizations of such decision procedures (three based on derivatives, two on marked regular expressions) can be obtained as instances of the framework. We discover that the two approaches based on marked regular expressions, which were previously thought to be the same, are different, and we prove a quotient relation between the automata produced by them. The common framework makes it possible to compare the performance of the different decision procedures in a meaningful way. 1
http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva207378 Program Analysis and Verification based on Kleene Algebra in Isabelle/HOL
"... N.B. When citing this work, cite the original published paper. Permanent link to this version: ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
N.B. When citing this work, cite the original published paper. Permanent link to this version:
Verified Synthesis of KnowledgeBased Programs in Finite Synchronous Environments
, 2013
"... Knowledgebased programs (KBPs) are a formalism for directly relating an agent’s knowledge and behaviour. Here we present a general scheme for compiling KBPs to executable automata with a proof of correctness in Isabelle/HOL. We develop the algorithm topdown, using Isabelle’s locale mechanism to st ..."
Abstract
 Add to MetaCart
(Show Context)
Knowledgebased programs (KBPs) are a formalism for directly relating an agent’s knowledge and behaviour. Here we present a general scheme for compiling KBPs to executable automata with a proof of correctness in Isabelle/HOL. We develop the algorithm topdown, using Isabelle’s locale mechanism to structure these proofs, and show that two classic examples