Valigator: A Verification Tool with Bound and Invariant Generation

Henzinger, Thomas A.; Hottelier, Thibaud; Kovács, Laura

doi:10.1007/978-3-540-89439-1_24

Cited by 18 publications

(15 citation statements)

References 14 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Similarly, the Why3 [18] verification platform generates VCs for C, Java, and Ada programs by converting them to an intermediate specification and programming language (WhyML). Similarly to Boogie, the Valigator tool [31] is able to infer loop invariants, but it uses different techniques (symbolic summation, Gröbner basis computation, and quantifier elimination) and the strongest postcondition calculus. The approach we have presented in this paper is able, like Boogie and Valigator, to automatically infer loop invariants.…”

Section: Related Work and Conclusionmentioning

confidence: 99%

Semantics-based generation of verification conditions via program specialization

Angelis

Fioravanti

Pettorossi

et al. 2017

Science of Computer Programming

View full text Add to dashboard Cite

We present a method for automatically generating verification conditions for a class of imperative programs and safety properties. Our method is parametric with respect to the semantics of the imperative programming language, as it generates the verification conditions by specializing, using unfold/fold transformation rules, a Horn clause interpreter that encodes that semantics.We define a multi-step operational semantics for a fragment of the C language and compare the verification conditions obtained by using this semantics with those obtained by using a more traditional small-step semantics. The flexibility of the approach is further demonstrated by showing that it is possible to easily take into account alternative operational semantics definitions for modeling additional language features. We have proved that the verification condition generation takes a number of transformation steps that is linear with respect to the size of the imperative program to be verified. Also the size of the verification conditions is linear with respect to the size of the imperative program. Besides the theoretical computational complexity analysis, we also provide an experimental evaluation of the method by generating verification conditions using the multi-step and the small-step semantics for a few hundreds of programs taken from various publicly available benchmarks, and by checking the satisfiability of these verification conditions by using state-of-the-art Horn clause solvers. These experiments show that automated verification of programs from a formal definition of the operational semantics is indeed feasible in practice.

show abstract

Section: Related Work and Conclusionmentioning

confidence: 99%

Semantics-based generation of verification conditions via program specialization

Angelis

Fioravanti

Pettorossi

et al. 2017

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…For example, these formulas can express the values of loop variables in terms of the loop counter, monotonicity properties of these variables considered as functions of the loop counter and polynomial relations among these variables. For extracting this information we deploy techniques from symbolic computation, such as recurrence solving and quantifier elimination, as presented in [3], [1], to perform inductive reasoning over scalar variables. (2) Using the derived loop properties, we then automatically discover first-order properties of the so-called update predicates for array variables used in the loop and monotonicity properties for scalar variables.…”

Section: Extended Abstractmentioning

confidence: 99%

Finding Loop Invariants for Programs over Arrays Using a Theorem Prover

Kovács

Воронков

2009

2009 11th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing

View full text Add to dashboard Cite

EXTENDED ABSTRACTInvariants with quantifiers are important for verification and static analysis of programs over arrays due to the unbounded nature of arrays. Such invariants can express relationships among array elements and properties involving array and scalar variables of the loop.This talk presents how quantified loop invariants of programs over arrays can be automatically inferred using a first order theorem prover, reducing the burden of annotating loops with complete invariants. Unlike all previously known methods, our method is able to generate loop invariants containing quantifier alternations.The method is based on the following steps. (1) Given a loop over array and scalar variables, we first try to extract from it various information that can be expressed by first-order formulas. For example, these formulas can express the values of loop variables in terms of the loop counter, monotonicity properties of these variables considered as functions of the loop counter and polynomial relations among these variables. For extracting this information we deploy techniques from symbolic computation, such as recurrence solving and quantifier elimination, as presented in [3], [1], to perform inductive reasoning over scalar variables.(2) Using the derived loop properties, we then automatically discover first-order properties of the so-called update predicates for array variables used in the loop and monotonicity properties for scalar variables. The update predicates describe the positions at which arrays are updated, iterations at which the updates occur and the update values. The first-order information extracted from the loop description can use auxiliary symbols, such as symbols denoting update predicates or loop counters. By relying on the update predicates of arrays and the monotonicity properties of scalars, we avoid inductive reasoning over arrays.(3) After having collected the first-order information, we run a saturation theorem prover to eliminate the auxiliary symbols and obtain loop invariants expressed as first-order formulas. In our work we used the first-order theorem prover Vampire [4]. To make Vampire suitable for invariant generation we had to extend it in two ways: (i) add a sound but incomplete axiomatisation of linear integer arithmetic that is sufficient for proving many essential properties of integers, and (ii) use a reduction ordering that makes all auxiliary symbols large in precedence and having a large weight in the Knuth-Bendix ordering used by Vampire. When the invariants derived by Vampire contain skolem functions, we de-skolemise them into formulas with quantifier alternations. The main features of our technique are the following.• We require no user guidance such as a postcondition or a collection of predicates from which an invariant can be built: all we have is a loop description. • We avoid inductive reasoning over the array content. • We are able to generate automatically complex invariants involving quantifier alternations. We have successfully tried our method on a number of ex...

show abstract

“…Our method has thus advantage in automation, but it is restricted to ABC-loops. The approach presented in [11] infers invariants and bound assertions for loops with nested conditionals and assignments, where the assignments statements describe non-trivial recurrence relations over program variables (i.e. variable initializations are not allowed).…”

Section: Introductionmentioning

confidence: 99%

“…Bounds on iteration counters can be finally inferred if the iteration counters are changed by each path in the same manner. Due to these restrictions, nested loops cannot be handled in [11]. Contrarily to [11], we infer bound assertions as z-relations for nested loops, but, unlike [11], our invariant assertions are only over loop iteration variables and not arbitrary program variables.…”

Section: Introductionmentioning

confidence: 99%

ABC: Algebraic Bound Computation for Loops

Blanc

Henzinger

Hottelier

et al. 2010

Logic for Programming, Artificial Intelligence, and Reasoning

Self Cite

View full text Add to dashboard Cite

Abstract. We present ABC, a software tool for automatically computing symbolic upper bounds on the number of iterations of nested program loops. The system combines static analysis of programs with symbolic summation techniques to derive loop invariant relations between program variables. Iteration bounds are obtained from the inferred invariants, by replacing variables with bounds on their greatest values. We have successfully applied ABC to a large number of examples. The derived symbolic bounds express non-trivial polynomial relations over loop variables. We also report on results to automatically infer symbolic expressions over harmonic numbers as upper bounds on loop iteration counts.

show abstract

Valigator: A Verification Tool with Bound and Invariant Generation

Cited by 18 publications

References 14 publications

Semantics-based generation of verification conditions via program specialization

Semantics-based generation of verification conditions via program specialization

Finding Loop Invariants for Programs over Arrays Using a Theorem Prover

ABC: Algebraic Bound Computation for Loops

Contact Info

Product

Resources

About