Results 1  10
of
18
A Fully Verified Executable LTL Model Checker
"... We present an LTL model checker whose code has been completely verified using the Isabelle theorem prover. The checker consists of over 4000 lines of ML code. The code is produced using recent Isabelle technology called the Refinement Framework, which allows us to split its correctness proof into ( ..."
Abstract

Cited by 7 (3 self)
 Add to MetaCart
(Show Context)
We present an LTL model checker whose code has been completely verified using the Isabelle theorem prover. The checker consists of over 4000 lines of ML code. The code is produced using recent Isabelle technology called the Refinement Framework, which allows us to split its correctness proof into (1) the proof of an abstract version of the checker, consisting of a few hundred lines of “formalized pseudocode”, and (2) a structures are replaced by implementations of efficient structures like redblack trees and functional arrays. This leads to a checker that, while still slower than unverified checkers, can already be used as a trusted reference implementation against which advanced implementations can be tested. We report on the structure of the checker, the development process, and some experiments on standard benchmarks.
Animating the formalised semantics of a Javalike language
 In Interactive Theorem Proving, volume 6898 of LNCS
, 2011
"... ..."
(Show Context)
Refinement for Monadic Programs
"... We provide a framework for program and data refinement in Isabelle/HOL. The framework is based on a nondeterminismmonad with assertions, i.e., the monad carries a set of results or an assertion failure. Recursion is expressed by fixed points. For convenience, we also provide while and foreach combi ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
We provide a framework for program and data refinement in Isabelle/HOL. The framework is based on a nondeterminismmonad with assertions, i.e., the monad carries a set of results or an assertion failure. Recursion is expressed by fixed points. For convenience, we also provide while and foreach combinators. The framework provides tools to automatize canonical tasks, such as verification condition generation, finding appropriate data refinement relations, and refine an executable program to a form that is accepted by the Isabelle/HOL code generator. This submission comes with a collection of examples and a userguide,
A Framework for Verified DepthFirst Algorithms
"... We present a framework in Isabelle/HOL for formalizing variants of depthfirst search. This framework allows to easily prove nontrivial properties of these variants. Moreover, verified code in several programming languages including Haskell, Scala and Standard ML can be generated. In this paper, we ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We present a framework in Isabelle/HOL for formalizing variants of depthfirst search. This framework allows to easily prove nontrivial properties of these variants. Moreover, verified code in several programming languages including Haskell, Scala and Standard ML can be generated. In this paper, we present an abstract formalization of depthfirst search and demonstrate how it is refined to an efficiently executable version. Further we use the emptinessproblem of Büchiautomata known from model checking as the motivation to present three Nested DFS algorithms. They are formalized, verified and transformed into executable code using our framework.
Verified efficient implementation of Gabow’s strongly connected component algorithm
 In Proc. of ITP
, 2014
"... Abstract. We present an Isabelle/HOL formalization of Gabow’s algorithm for finding the strongly connected components of a directed graph. Using data refinement techniques, we extract efficient code that performs comparable to a reference implementation in Java. Our style of formalization allows fo ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We present an Isabelle/HOL formalization of Gabow’s algorithm for finding the strongly connected components of a directed graph. Using data refinement techniques, we extract efficient code that performs comparable to a reference implementation in Java. Our style of formalization allows for reusing large parts of the proofs when defining variants of the algorithm. We demonstrate this by verifying an algorithm for the emptiness check of generalized Büchi automata, reusing most of the existing proofs. 1
Contents
, 2009
"... Dynamic Pushdown Networks (DPNs) are a model for concurrent programs with recursive procedures and thread creation. We formalize a trueconcurrency semantics for DPNs. Executions of this semantics have a tree structure. We show the relation of our semantics to the original interleavings semantics. W ..."
Abstract
 Add to MetaCart
(Show Context)
Dynamic Pushdown Networks (DPNs) are a model for concurrent programs with recursive procedures and thread creation. We formalize a trueconcurrency semantics for DPNs. Executions of this semantics have a tree structure. We show the relation of our semantics to the original interleavings semantics. We then show how to compute predecessor sets of regular sets of configurations w.r.t. treeregular constraints on the execution. Acquisition histories have been introduced by Kahlon et al. to modelcheck parallel pushdown systems with wellnested locks, but without thread creation. We generalize acquisistion histories to be used with DPNs. For this purpose, our treebased semantics can be naturally applied. Moreover, the generalized acquisition histories enable us to characterize the (treebased) executions that have a schedule that is valid w.r.t. locks, thus obtaining an algorithm to compute locksensitive predecessor sets.
Contents
, 2013
"... We provide the operations of matrix addition, multiplication, transposition, and matrix comparisons as executable functions over ordered semirings. Moreover, it is proven that strongly normalizing (monotone) orders can be lifted to strongly normalizing (monotone) orders over matrices. We further sho ..."
Abstract
 Add to MetaCart
(Show Context)
We provide the operations of matrix addition, multiplication, transposition, and matrix comparisons as executable functions over ordered semirings. Moreover, it is proven that strongly normalizing (monotone) orders can be lifted to strongly normalizing (monotone) orders over matrices. We further show that the standard semirings over the naturals, integers, and rationals, as well as the arctic semirings satisfy the axioms that are required by our matrix theory. Our formalization was performed as part of the IsaFoR/CeTAsystem [3] 1 which contains several termination techniques. The provided theories have been essential to formalize matrixinterpretations [1] and arctic interpretations [2]. A short description of this formalization can be found in [4].
3.2 Basic operations on Graphs................... 5
, 2013
"... We implement and prove correct Dijkstra’s algorithm for the single source shortest path problem, conceived in 1956 by E. Dijkstra. The algorithm is implemented using the data refinement framework for monadic, nondeterministic programs. An efficient implementation ..."
Abstract
 Add to MetaCart
(Show Context)
We implement and prove correct Dijkstra’s algorithm for the single source shortest path problem, conceived in 1956 by E. Dijkstra. The algorithm is implemented using the data refinement framework for monadic, nondeterministic programs. An efficient implementation
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
LightWeight Containers
"... This development provides a framework for container types like sets and maps such that generated code implements these containers with different (efficient) data structures. Thanks to type classes and refinement during code generation, this lightweight approach can seamlessly replace Isabelle’s def ..."
Abstract
 Add to MetaCart
(Show Context)
This development provides a framework for container types like sets and maps such that generated code implements these containers with different (efficient) data structures. Thanks to type classes and refinement during code generation, this lightweight approach can seamlessly replace Isabelle’s default setup for code generation. Heuristics automatically pick one of the available data structures depending on the type of elements to be stored, but users can also choose on their own. The extensible design permits to add more implementations at any time. To support arbitrary nesting of sets, we define a linear order on sets based on a linear order of the elements and provide efficient implementations. It even allows to compare complements with noncomplements. Contents