Results

**1 - 7**of**7**### Checking Validity of Quantifier-Free Formulas in Combinations of First-Order Theories

, 2003

"... ii ..."

(Show Context)
### A MuDDy Experience-ML Bindings To A BDD Library

"... Abstract. Binary Decision Diagrams (BDDs) are a data structure used to efficiently represent boolean expressions on canonical form. BDDs are often the core data structure in model checkers. MuDDy is an ML interface (both for Standard ML and Objective Caml) to the BDD package BuDDy that is written i ..."

Abstract
- Add to MetaCart

(Show Context)
Abstract. Binary Decision Diagrams (BDDs) are a data structure used to efficiently represent boolean expressions on canonical form. BDDs are often the core data structure in model checkers. MuDDy is an ML interface (both for Standard ML and Objective Caml) to the BDD package BuDDy that is written in C. This combination of an ML interface to a high-performance C library is surprisingly fruitful. ML allows you to quickly experiment with high-level symbolic algorithms before handing over the grunt work to the C library. I show how, with a relatively little effort, you can make a domain specific language for concurrent finite state-machines embedded in Standard ML and then write various custom model-checking algorithms for this domain specific embedded language (DSEL).

### Contents

, 2013

"... This article is an Isabelle formalisation of a paper with the same. In a similar way as Knuth’s 0-1-principle for sorting algorithms, that ..."

Abstract
- Add to MetaCart

(Show Context)
This article is an Isabelle formalisation of a paper with the same. In a similar way as Knuth’s 0-1-principle for sorting algorithms, that

### What is a sorting function?

- THE JOURNAL OF LOGIC AND ALGEBRAIC PROGRAMMING
, 2009

"... ..."

(Show Context)
### A purely functional implementation of ROBDDs in Haskell

"... This paper presents an implementation of the ROBDD data structure in Haskell. It shows that lazy evaluation can be used to improve the performance of some ROBDD algorithms. While standard implementations construct the whole structure no matter which parts are demanded we use lazy evaluation to provi ..."

Abstract
- Add to MetaCart

(Show Context)
This paper presents an implementation of the ROBDD data structure in Haskell. It shows that lazy evaluation can be used to improve the performance of some ROBDD algorithms. While standard implementations construct the whole structure no matter which parts are demanded we use lazy evaluation to provide a more demand driven construction. To achieve this behavior we have to relax a property that guarantees that ROBDDs contain no redundant nodes. All measurements show that relaxing causes only a small number of additional nodes. Furthermore we present an equality check implementation that performs well although it does not make use of canoicity. The canonicity is lost because of the relaxing. The equality check implementation benefits highly from laziness. 1

### Meta-Programming With Intensional Analysis

"... syntax as an MetaMLdatatype declare x = 10 in -- x := x - 1; print x Sample program in concrete Syntax val S1 = Declare("x",Constant 10, Seq(Assign("x",Minus(Variable "x", Constant 1)), Print(Variable "y"))); Datatype encoding of sample program. !Do ..."

Abstract
- Add to MetaCart

syntax as an MetaMLdatatype declare x = 10 in -- x := x - 1; print x Sample program in concrete Syntax val S1 = Declare("x",Constant 10, Seq(Assign("x",Minus(Variable "x", Constant 1)), Print(Variable "y"))); Datatype encoding of sample program. !Do %mswo -- %push 10 ; a !- %read 1 ; b !- Return %mswo a %- 1 ; c !- %write 1 b ; d !- %read 1 ; e !- %output d ; Return %mswo () ; %pop ? Residual result of staging example program. (* interpret2 : Com -? index -? !unit M? *) fun interpret2 stmt index = case stmt of Assign(name,e) =? let val loc = position name index in !Do mswo -- n !- ~(eval2 e index) ; write ~(lift loc) n ? end --- Seq(s1,s2) =? !Do mswo -- x !- ~(interpret2 s1 index) ; y !- ~(interpret2 s2 index) ; Return mswo () ? --- Cond(e,s1,s2) =? !Do mswo -- x !- ~(eval2 e index) ; if x=1 then ~(interpret2 s1 index) else ~(interpret2 s2 index)? --- While(e,b) =? !let fun loop () = Do mswo -- v !- ~(eval2 e index) ; if v=0 then Return mswo...

### Acta Informatica manuscript No. (will be inserted by the editor) Refined Typing to Localize the Impact of Forced Strictness on Free Theorems ⋆

, 2011

"... Abstract Free theorems establish interesting properties of parametrically polymorphic functions, solely from their types, and serve as a nice proof tool. For pure and lazy functional programming languages, they can be used with very few preconditions. Unfortunately, in the presence of selective stri ..."

Abstract
- Add to MetaCart

(Show Context)
Abstract Free theorems establish interesting properties of parametrically polymorphic functions, solely from their types, and serve as a nice proof tool. For pure and lazy functional programming languages, they can be used with very few preconditions. Unfortunately, in the presence of selective strictness, as provided in languages like Haskell, their original strength is reduced. In this paper we present an approach for overcoming this weakness in specific situations. Employing a refined type system which tracks the use of enforced strict evaluation, we rule out unnecessary restrictions that otherwise emerge. Additionally, we provide (and implement) an algorithm determining all refined types for a given term. 1