• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations | Disambiguate

An Overview of the Leon Verification System: Verification by Translation to Recursive Functions (2013)

by R Blanc, E Kneuss, V Kuncak, P Suter
Venue:In Scala Workshop
Add To MetaCart

Tools

Sorted by:
Results 1 - 9 of 9

Synthesis Modulo Recursive Functions

by Etienne Kneuss, Viktor Kuncak, Ivan Kuraj, Philippe Suter , 2013
"... ..."
Abstract - Cited by 13 (10 self) - Add to MetaCart
Abstract not found

On Sound Compilation of Reals

by Eva Darulova, Viktor Kuncak
"... Writing accurate numerical software is hard because of many sources of unavoidable uncertainties, including finite numerical precision of implementations. We present a programming model where the user writes a program in a real-valued implementation and specification language that explicitly include ..."
Abstract - Cited by 9 (4 self) - Add to MetaCart
Writing accurate numerical software is hard because of many sources of unavoidable uncertainties, including finite numerical precision of implementations. We present a programming model where the user writes a program in a real-valued implementation and specification language that explicitly includes different types of uncertainties. We then present a compilation algorithm that generates a conventional implementation that is guaranteed to meet the desired precision with respect to real numbers. Our verification step generates verification conditions that treat different uncertainties in a unified way and encode reasoning about floating-point roundoff errors into reasoning about real numbers. Such verification conditions can be used as a standardized format for verifying the precision and the correctness of numerical programs. Due to their often non-linear nature, precise reasoning about such verification conditions remains difficult. We show that current state-of-the art SMT solvers do not scale well to solving such verification conditions. We propose a new procedure that combines exact SMT solving over reals with approximate and sound affine and interval arithmetic. We show that this approach overcomes scalability limitations of SMT solvers while providing improved precision over affine and interval arithmetic. Using our initial implementation we show the usefullness and effectiveness of our approach on several examples, including those containing non-linear computation. 1.
(Show Context)

Citation Context

...ation condition generation, analysis of possibly non-linear expressions, and the handling of conditionals. Our system is implemented as an extension of the Leon verifier for functional Scala programs =-=[7]-=-. The implementation relies on a range arithmetic implementation [15] for Scala as well as on the Z3 SMT solver [20]. We have evaluated the system on a number of diverse benchmarks, obtaining promisin...

Executing Specifications using Synthesis and Constraint Solving

by Viktor Kuncak, Etienne Kneuss
"... Abstract. Specifications are key to improving software reliability as well as documenting precisely the intended behavior of software. Writing specifications is still perceived as expensive. Of course, writing implementations is at least as expensive, but is hardly questioned because there is curren ..."
Abstract - Cited by 6 (4 self) - Add to MetaCart
Abstract. Specifications are key to improving software reliability as well as documenting precisely the intended behavior of software. Writing specifications is still perceived as expensive. Of course, writing implementations is at least as expensive, but is hardly questioned because there is currently no real alternative. Our goal is to give specifications a more balanced role compared to implementations, enabling the developers to compile, execute, optimize, and verify against each other mixed code fragments containing both specifications and implementations. To make specification constructs executable we combine deductive synthesis with run-time constraint solving, in both cases leveraging modern SMT solvers. Our tool decomposes specifications into simpler fragments using a cost-driven deductive synthesis framework. It compiles as many fragments as possible into conventional functional code; it executes the remaining fragments by invoking our constraint solver that extends an SMT solver to handle recursive functions. Using this approach we were able to execute constraints that describe the desired properties of integers, sets, maps and algebraic data types. 1
(Show Context)

Citation Context

...ecutable. Our current approach combines deductive synthesis with run-time constraint solving, in both cases leveraging modern SMT solvers. We have built a tool as part of the Leon verification system =-=[9]-=- that incorporates both techniques and allows us to experiment with their trade-offs. A version of the Leon platform is publicly available in source code form for further experiments at http://lara.ep...

Checking Data Structure Properties Orders of Magnitude Faster

by Emmanouil Koukoutos, Viktor Kuncak
"... Abstract. Executable formal contracts help verify a program at run-time when static verification fails. However, these contracts may be pro-hibitively slow to execute, especially when they describe the transforma-tions of data structures. In fact, often an efficient data structure opera-tion with O( ..."
Abstract - Cited by 2 (1 self) - Add to MetaCart
Abstract. Executable formal contracts help verify a program at run-time when static verification fails. However, these contracts may be pro-hibitively slow to execute, especially when they describe the transforma-tions of data structures. In fact, often an efficient data structure opera-tion with O(log(n)) running time executes in O(n log(n)) when naturally written specifications are executed at run time. We present a set of techniques that improve the efficiency of run-time checks by orders of magnitude, often recovering the original asymptotic behavior of operations. Our implementation first removes any statically verified parts of checks. Then, it applies a program transformation that changes recursively computed properties into data structure fields, en-suring that properties are evaluated no more than once on a given data structure node. We present evaluation of our techniques on the Leon system for verification of purely functional programs. 1
(Show Context)

Citation Context

...bstantially improve the performance of runtime checks that remain after static verification attempts. Our system works for a purely functional subset of Scala recognized by the Leon verification tool =-=[1]-=-, [8]. It provides executable formal contracts in the form of pre- and postconditions of functions, and supports algebraic data types (ADTs). Our implementation and the benchmarks we used to evaluate ...

Counter-Example Complete Verification for Higher-Order Functions

by Nicolas Voirol, Etienne Kneuss, Viktor Kuncak
"... We present a verification procedure for pure higher-order functional Scala programs with parametric types. We show that our procedure is sound for proofs, as well as sound and complete for counter-examples. The procedure reduces the analysis of higher-order programs to checking satisfiability of a s ..."
Abstract - Add to MetaCart
We present a verification procedure for pure higher-order functional Scala programs with parametric types. We show that our procedure is sound for proofs, as well as sound and complete for counter-examples. The procedure reduces the analysis of higher-order programs to checking satisfiability of a sequence of quantifier-free formulas over theories such as algebraic data types, integer linear arithmetic, and unin-terpreted function symbols, thus enabling the use of efficient satisfiability modulo theory (SMT) solvers. Our solution supports arbitrary function types and arbi-trarily nested anonymous functions (which can be stored in data structures, passed as arguments, returned, and applied). Among the contributions of this work is supporting even those cases when anonymous functions cannot be statically traced back to their definition, ensuring completeness of the approach for finding counter-examples. We provide a proof of soundness and counter-example completeness for our system as well as initial evaluation in the Leon verifier.
(Show Context)

Citation Context

...r/author(s). ACM 978-1-4503-3626-0/15/06. http://dx.doi.org/10.1145/2774975.2774978 1. Introduction Functional languages are well suited for verification due to their clear semantics [6]. Recent work =-=[3, 19]-=- has shown that recursive programs over unbounded data types can be precisely handled using unfolding-based approaches. However, one of the main features of functional languages, namely higher-order f...

Sound Reasoning about Integral Data Types with a Reusable SMT Solver Interface

by Régis Blanc, Viktor Kuncak
"... We extend the Leon verification system for Scala with support for bit-vector reasoning, thus addressing one of its fundamen-tal soundness limitation with respect to the treatment of inte-gers primitives. We leverage significant progresses recently achieved in SMT solving by developing a solver-indep ..."
Abstract - Add to MetaCart
We extend the Leon verification system for Scala with support for bit-vector reasoning, thus addressing one of its fundamen-tal soundness limitation with respect to the treatment of inte-gers primitives. We leverage significant progresses recently achieved in SMT solving by developing a solver-independent interface to easily configure the back-end of Leon. Our inter-face is based on the emerging SMT-LIB standard for SMT solvers, and we release a Scala library offering full support for the latest version of the standard. We use the standard BigInt Scala library to represent math-ematical integers, whereas we correctly model Int as 32-bit integers. We ensure safety of arithmetic by checking for di-vision by zero and correctly modeling division and modulo. We conclude with a performance comparison between the sound representation of Ints and the cleaner abstract represen-tation using mathematical integers, and discuss the trade-off involved.
(Show Context)

Citation Context

...mplements a lazy unrolling algorithm to deal with recursive functions, by alternating between an abstraction using uninterpreted functions and adding assumptions to only consider fully unrolled paths =-=[3, 19]-=-. Previous state. Previously, Leon mapped Scala’s Int data type into the mathematical integers of the underlying theorem prover. One could argue that the mathematical integers correspond to many typic...

Developing Verified Software Using Leon

by Viktor Kuncak
"... Abstract. We present Leon, a system for developing functional Scala programs annotated with contracts. Contracts in Leon can themselves refer to recursively defined functions. Leon aims to find counterexam-ples when functions do not meet the specifications, and proofs when they do. Moreover, it can ..."
Abstract - Add to MetaCart
Abstract. We present Leon, a system for developing functional Scala programs annotated with contracts. Contracts in Leon can themselves refer to recursively defined functions. Leon aims to find counterexam-ples when functions do not meet the specifications, and proofs when they do. Moreover, it can optimize run-time checks by eliminating stati-cally checked parts of contracts and doing memoization. For verification Leon uses an incremental function unfolding algorithm (which could be viewed as k-induction) and SMT solvers. For counterexample finding it uses these techniques and additionally specification-based test genera-tion. Leon can also execute specifications (e.g. functions given only by postconditions), by invoking a constraint solver at run time. To make this process more efficient and predictable, Leon supports deductive synthesis of functions from specifications, both interactively and in an automated mode. Synthesis in Leon is currently based on a custom deductive syn-thesis framework incorporating, for example, syntax-driven rules, rules supporting synthesis procedures, and a form of counterexample-guided synthesis. We have also developed resource bound invariant inference for Leon and used it to check abstract worst-case execution time. We have also explored within Leon a compilation technique that transforms real-valued program specifications into finite-precision code while enforcing the desired end-to-end error bounds. Recent work enables Leon to per-form program repair when the program does not meet the specification, using error localization, synthesis guided by the original expression, and counterexample-guided synthesis of expressions similar to a given one. Leon is open source and can also be tried from its web environment at leon.epfl.ch. 1
(Show Context)

Citation Context

... compiler front end; a Leon program is a valid Scala program. For convenience, Leon also supports local functions, local mutable variables and while loops, which are expanded into recursive functions =-=[1]-=-. Among related tools to Leon as far as verification functionality is concerned are liquid types [27], though Leon has a real model checking flavor in that it returns only valid counterexamples. Leon ...

Model Finding for Recursive Functions in SMT∗

by Andrew Reynolds, Jasmin Christian Blanchette, Cesare Tinelli
"... SMT solvers have recently been extended with techniques for finding models in presence of universally quantified formulas in some restricted fragments. This paper introduces a translation which reduces ax-ioms specifying a large class of recursive functions, including well-founded (terminating) func ..."
Abstract - Add to MetaCart
SMT solvers have recently been extended with techniques for finding models in presence of universally quantified formulas in some restricted fragments. This paper introduces a translation which reduces ax-ioms specifying a large class of recursive functions, including well-founded (terminating) functions, to universally quantified formulas for which these techniques are applicable. An empirical evaluation con-firms that the approach improves the performance of existing solvers on benchmarks from two sources. The translation is implemented as a preprocessor in the solver CVC4. 1
(Show Context)

Citation Context

... definitions, unsatisfiability, and makes finite model finding possible for problems in this class. Our empirical evaluation on benchmarks from the IsaPlanner proof planner [16] and the Leon verifier =-=[5]-=- provides evidence that this translation improves the effectiveness of the SMT solvers CVC4 and Z3 for finding countermodels to verification conditions (Section 4). The approach is implemented as a pr...

Verifying and Synthesizing Software with Recursive Functions (Invited Contribution)

by Viktor Kuncak
"... Abstract. Our goal is to help people construct software that does what they wish. We develop tools and algorithms that span static and dynamic verification, constraint solving, and program synthesis. I will outline the current state our verification and synthesis system, Leon, which trans-lates soft ..."
Abstract - Add to MetaCart
Abstract. Our goal is to help people construct software that does what they wish. We develop tools and algorithms that span static and dynamic verification, constraint solving, and program synthesis. I will outline the current state our verification and synthesis system, Leon, which trans-lates software into a functional language and uses SMT solvers to reason about paths in programs and specifications. Certain completeness results partly explain the effectiveness of verification and synthesis procedures implemented within Leon, in particular results on decidability of suffi-ciently surjective abstraction functions, and the framework of complete functional synthesis. 1
Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University