Results 1  10
of
11
Dependency pairs for rewriting with builtin numbers and semantic data structures
, 2007
"... Abstract. This paper defines an expressive class of constrained equational rewrite systems that supports the use of semantic data structures (e.g., sets or multisets) and contains builtin numbers, thus extending our previous work presented at CADE 2007 [6]. These rewrite systems, which are based on ..."
Abstract

Cited by 6 (5 self)
 Add to MetaCart
(Show Context)
Abstract. This paper defines an expressive class of constrained equational rewrite systems that supports the use of semantic data structures (e.g., sets or multisets) and contains builtin numbers, thus extending our previous work presented at CADE 2007 [6]. These rewrite systems, which are based on normalized rewriting on constructor terms, allow the specification of algorithms in a natural and elegant way. Builtin numbers are helpful for this since numbers are a primitive data type in every programming language. We develop a dependency pair framework for these rewrite systems, resulting in a flexible and powerful method for showing termination that can be automated effectively. Various powerful techniques are developed within this framework, including a subterm criterion and reduction pairs that need to consider only subsets of the rules and equations. It is wellknown from the dependency pair framework for ordinary rewriting that these techniques are often crucial for a successful automatic termination proof. Termination of a large collection of examples can be established using the presented techniques. 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
Operational termination of conditional rewriting with builtin numbers and semantic data structures
, 2007
"... Abstract. Rewrite systems on free data structures have limited expressive power since semantic data structures like sets or multisets cannot be modeled elegantly. In this work we define a class of rewrite systems that allows the use of semantic data structures. Additionally, builtin natural numbers ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Rewrite systems on free data structures have limited expressive power since semantic data structures like sets or multisets cannot be modeled elegantly. In this work we define a class of rewrite systems that allows the use of semantic data structures. Additionally, builtin natural numbers, including (dis)equality, ordering, and divisibility constraints, are supported. The rewrite mechanism is a combination of normalized equational rewriting with evaluation of conditions and validity checking of instantiated constraints. The framework is highly expressive and allows modeling of algorithms in a natural way. Termination is one of the most important properties of conditional normalized equational rewriting. For this it is not sufficient to only show wellfoundedness of the rewrite relation, but it also has to be ensured that evaluation of the conditions does not loop. The notion of operational termination is a way to capture these properties. In this work we show that it is possible to transform a conditional constrained equational rewrite system into an unconditional one such that termination of the latter implies operational termination of the former. Methods for showing termination of unconditional constrained equational rewrite system are presented in a companion paper. 1
Termination of ContextSensitive Rewriting with BuiltIn Numbers and Collection Data Structures ⋆
"... Abstract. Contextsensitive rewriting is a restriction of rewriting that can be used to elegantly model declarative specification and programming languages such as Maude. Furthermore, it can be used to model lazy evaluation in functional languages such as Haskell. Building upon our previous work on ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Contextsensitive rewriting is a restriction of rewriting that can be used to elegantly model declarative specification and programming languages such as Maude. Furthermore, it can be used to model lazy evaluation in functional languages such as Haskell. Building upon our previous work on an expressive and elegant class of rewrite systems (called CERSs) that contains builtin numbers and supports the use of collection data structures such as sets or multisets, we consider contextsensitive rewriting with CERSs in this paper. This integration results in a natural way for specifying algorithms in the rewriting framework. In order to prove termination of this kind of rewriting automatically, we develop a dependency pair framework for contextsensitive rewriting with CERSs, resulting in a flexible termination method that can be automated effectively. Several powerful termination techniques are developed within this framework. An implementation in the termination prover AProVE has been successfully evaluated on a large collection of examples. 1
Conversion by Evaluation Mathieu Boespflug ⋆
"... Abstract. We show how testing convertibility of two types in dependently typed systems can advantageously be implemented instead untyped normalization by evaluation, thereby reusing existing compilers and runtime environments for stock functional languages, without peeking under the hood, for a fast ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We show how testing convertibility of two types in dependently typed systems can advantageously be implemented instead untyped normalization by evaluation, thereby reusing existing compilers and runtime environments for stock functional languages, without peeking under the hood, for a fast yet cheap system in terms of implementation effort. Our focus is on performance of untyped normalization by evaluation. We demonstrate that with the aid of a standard optimization for higher order programs (namely uncurrying), the reuse of native datatypes and pattern matching facilities of the underlying evaluator, we may obtain a normalizer with little to no performance overhead compared to a regular evaluator. 1
ProjectTeam PROTHEO Constraints, Mechanized Deduction and Proofs of Software Properties
"... c t i v it y e p o r t 2007 Table of contents ..."
(Show Context)
ProjectTeam PROTHEO Constraints, Mechanized Deduction and Proofs of Software Properties
"... d ' ctivity ..."
(Show Context)
Postdoc subject of the ARC Quotient Automatic generation of certified construction functions guaranteeing algebraic invariants on concrete data types
"... Concrete data types and patternmatching are salient features of modern programming languages as powerful ways of defining and manipulating data structures. Among other things (eg. abstract syntax trees, regular expressions, DNA sequences, chemistry, cellular automata), the developments of XML great ..."
Abstract
 Add to MetaCart
(Show Context)
Concrete data types and patternmatching are salient features of modern programming languages as powerful ways of defining and manipulating data structures. Among other things (eg. abstract syntax trees, regular expressions, DNA sequences, chemistry, cellular automata), the developments of XML greatly increases the interest in more complex patternmatching for easily writing programs transforming or querying XML documents. Various functional programming languages are extended with XML specific data types and matching (eg. OcamlDuce). Even some wellknown nonfunctional programming languages (eg. C, Java) are extended with such complex patternmatching (eg. TOM 1). Although concrete date types are very useful in defining complex data structures, they are not always sufficient to adequately specify the data structures manipulated by the algorithms. Often, only a subset of the concrete data type is in fact used since some invariants between the components are mandatory to ensure the correctness of the program. For instance, some list have to be sorted