57 research outputs found
Predicate Abstraction for Linked Data Structures
We present Alias Refinement Types (ART), a new approach to the verification
of correctness properties of linked data structures. While there are many
techniques for checking that a heap-manipulating program adheres to its
specification, they often require that the programmer annotate the behavior of
each procedure, for example, in the form of loop invariants and pre- and
post-conditions. Predicate abstraction would be an attractive abstract domain
for performing invariant inference, existing techniques are not able to reason
about the heap with enough precision to verify functional properties of data
structure manipulating programs. In this paper, we propose a technique that
lifts predicate abstraction to the heap by factoring the analysis of data
structures into two orthogonal components: (1) Alias Types, which reason about
the physical shape of heap structures, and (2) Refinement Types, which use
simple predicates from an SMT decidable theory to capture the logical or
semantic properties of the structures. We prove ART sound by translating types
into separation logic assertions, thus translating typing derivations in ART
into separation logic proofs. We evaluate ART by implementing a tool that
performs type inference for an imperative language, and empirically show, using
a suite of data-structure benchmarks, that ART requires only 21% of the
annotations needed by other state-of-the-art verification techniques
Proving Type Class Laws for Haskell
Type classes in Haskell are used to implement ad-hoc polymorphism, i.e. a way
to ensure both to the programmer and the compiler that a set of functions are
defined for a specific data type. All instances of such type classes are
expected to behave in a certain way and satisfy laws associated with the
respective class. These are however typically just stated in comments and as
such, there is no real way to enforce that they hold. In this paper we describe
a system which allows the user to write down type class laws which are then
automatically instantiated and sent to an inductive theorem prover when
declaring a new instance of a type class.Comment: Presented at the Symposium for Trends in Functional Programming, 201
Verification of high-level transformations with inductive refinement types
International audienceHigh-level transformation languages like Rascal include expressive features for manipulating large abstract syntax trees: first-class traversals, expressive pattern matching, backtrack-ing and generalized iterators. We present the design and implementation of an abstract interpretation tool, Rabit, for verifying inductive type and shape properties for transformations written in such languages. We describe how to perform abstract interpretation based on operational semantics, specifically focusing on the challenges arising when analyzing the expressive traversals and pattern matching. Finally, we evaluate Rabit on a series of transformations (normaliza-tion, desugaring, refactoring, code generators, type inference, etc.) showing that we can effectively verify stated properties. CCS Concepts • Software and its engineering → General programming languages; • Social and professional topics → History of programming languages
A systematic review of the intrapersonal correlates of motivational climate perceptions in sport and physical activity
Perceptions of peer motivational climate in youth sport: Measurement development and implications for practice
- …