Invariant Generation in Vampire

@inproceedings{Hoder2011InvariantGI,
  title={Invariant Generation in Vampire},
  author={Krystof Hoder and Laura Kov{\'a}cs and Andrei Voronkov},
  booktitle={TACAS},
  year={2011}
}
This paper describes a loop invariant generator implemented in the theorem prover Vampire. It is based on the symbol elimination method proposed by two authors of this paper. The generator accepts a program written in a subset of C, finds loops in it, analyses the loops, generates and outputs invariants. It also uses a special consequence removal mode added to Vampire to remove invariants implied by other invariants. The generator is implemented as a standalone tool, thus no knowledge of… 
Reasoning About Loops Using Vampire
TLDR
A number of improvements and extensions to symbol elimination and invariant generation using first-order theorem proving, in particular the Vampire theorem prover are described, which turns symbol elimination into an automatic approach proving program correctness, providing an alternative method to Hoare-rule based loop verification or other deductive systems.
Case Studies on Invariant Generation Using a Saturation Theorem Prover
TLDR
This paper evaluates a program analysis method that uses first-order theorem proving techniques to automatically discover non-trivial program properties and discusses the relation of the program properties obtained by the implementation and the intended meaning of the programs used in the experiments.
Reasoning About Loops Over Arrays using Vampire
TLDR
This study suggests the inclusion of domain specific theory can enrich the reasoning process of a theorem provers, in this case the first-order theorem prover Vampire, and enhance the reasoningprocess of automated invariant generation for loop programs over unbounded arrays.
Analysis of Iterative or Recursive Programs Using a First-Order Theorem Prover
TLDR
An extension to the symbol elimination technique for automatic generation of loop invariants and ways to perform complete reasoning in the theory of term algebras in a first-order theorem prover are presented.
Lingva: Generating and Proving Program Properties Using Symbol Elimination
TLDR
The experiments show that Lingva can automatically generate quantified invariants, possibly with alternation of quantifiers, over integers and arrays, and can be used to prove program properties expressing the intended behavior of programs.
DYNAMATE : Automatic Checking loop invariants using Mutation, Dynamic Analysis and static checking
TLDR
The proposed system automates the functional verification of incomplete correctness of programs with loops by inferring the required loop invariants by combines complementary techniques such as test case generation, dynamic invariant detection, and static verification.
First-Order Theorem Proving and Vampire
TLDR
The superposition calculus is discussed and the key concepts of saturation and redundancy elimination are explained, present saturation algorithms and preprocessing, and demonstrate how these concepts are implemented in Vampire.
Explorer Mechanised Verification Patterns for Dafny
TLDR
This paper develops a tactic language for Dafny, extends this language with new features, implements a set of verification patterns in this tactic language, and shows, through experiments, generality of the patterns, and applicability of the tactic language.
Inferring Loop Invariants by Mutation, Dynamic Analysis, and Static Checking
TLDR
This work shows that significant loop invariant candidates can be generated by systematically mutating postconditions; then, dynamic checking weeds out invalid candidates, and static checking selects provably valid ones, paving the way for fully automatic verification without manually written loop invariants.
Mechanised Verification Patterns for Dafny
TLDR
This paper develops a tactic language for Dafny, extends this language with new features, implements a set of verification patterns in this tactic language, and shows, through experiments, generality of the patterns, and applicability of the tactic language.
...
1
2
3
4
...

References

SHOWING 1-10 OF 24 REFERENCES
Quantified Invariant Generation Using an Interpolating Saturation Prover
TLDR
This work shows how a paramodulation-based saturation prover can be modified in a simple way to produce a first-order interpolating prover that is complete for universally quantified interpolants, allowing the verification of programs manipulating arrays and heap data structures.
Finding Loop Invariants for Programs over Arrays Using a Theorem Prover
  • L. Kovács, A. Voronkov
  • Computer Science
    2009 11th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing
  • 2009
TLDR
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.
Aligators for Arrays (Tool Paper)
TLDR
Aligators leverages recurrence solving and algebraic techniques to carry out inductive reasoning over array content and allows treatment of multi-path loops by exploiting their commutativity and serializability properties.
Program verification using templates over predicate abstraction
TLDR
Three novel algorithms are presented, having different strengths, that combine template and predicate abstraction based formalisms to discover required sophisticated program invariants using SMT solvers, and can verify program properties that, to the knowledge, have not been automatically verified before.
Aligators for arrays
TLDR
The experience in applying Aligators on a collection of loops from open source software projects indicates the applicability of recurrence and algebraic solving techniques for reasoning about arrays.
InvGen: An Efficient Invariant Generator
TLDR
In this paper, InvGen is presented, an automatic linear arithmetic invariant generator for imperative programs that uses dynamic analysis to make invariant generation order of magnitude more efficient.
iProver - An Instantiation-Based Theorem Prover for First-Order Logic (System Description)
TLDR
The design of iProver is discussed, which is an instantiation-based theorem prover based on Inst-Gen calculus, complete for first-order logic, and a combination of instantiation and ordered resolution.
System Description: E 0.81
TLDR
The latest version of E, an equational theorem prover for clausal logic with equality, is described, with special emphasis on the important aspects that have changed compared to previously described versions.
Interpolation and Symbol Elimination in Vampire
TLDR
This tool paper describes how proofs in which some symbols are colored are implemented in the first-order theorem prover Vampire, which is used for invariant generation and computing interpolants.
The Spec# Programming System: An Overview
TLDR
The goals and architecture of thespec# programming system, consisting of the object-oriented Spec# programming language, the Spec# compiler, and the Boogie static program verifier, are described.
...
1
2
3
...