In this paper we give a short introduction in first-order theorem proving and the use of the theorem prover VAMPIRE. We discuss the superposition calculus and explain the key concepts of saturation and redundancy elimination, present saturation algorithms and preprocessing, and demonstrate how these concepts are implemented in VAMPIRE. Further, we also cover more recent topics and features of VAMPIRE designed for advanced applications, including satisfiability checking, theory reasoning, interpolation, consequence elimination, and program analysis.

We present a new method for automatic generation of loop invariants for programs containing arrays. Unlike all previously known methods, our method allows one to generate first-order invariants containing alternations of quantifiers. The method is based on the automatic analysis of the so-called update predicates of loops. An update predicate for an array A expresses updates made to A. We observe that many properties of update predicates can be extracted automatically from the loop description and loop properties obtained by other methods such as a simple analysis of counters occurring in the loop, recurrence solving and quantifier elimination over loop variables. We run the theorem prover Vampire on some examples and show that non-trivial loop invariants can be generated.

Theorema is a project that aims at supporting the entire process of mathematical theory exploration within one coherent logic and software system. This survey paper illustrates the style of Theoremasupported mathematical theory exploration by a case study (the automated synthesis of an algorithm for the construction of Gröbner Bases) and gives an overview on some reasoners and organizational tools for theory exploration developed in the Theorema project.

No abstract

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...

One of the main challenges in the analysis of probabilistic programs is to compute invariant properties that summarise loop behaviours. Automation of invariant generation is still at its infancy and most of the times targets only expected values of the program variables, which is insufficient to recover the full probabilistic program behaviour. We present a method to automatically generate moment-based invariants of a subclass of probabilistic programs, called Prob-solvable loops, with polynomial assignments over random variables and parametrised distributions. We combine methods from symbolic summation and statistics to derive invariants as valid properties over higher-order moments, such as expected values or variances, of program variables. We successfully evaluated our work on several examples where full automation for computing higher-order moments and invariants over program variables was not yet possible.

We present a method for generating polynomial invariants for a subfamily of imperative loops operating on numbers, called the P-solvable loops. The method uses algorithmic combinatorics and algebraic techniques. The approach is shown to be complete for some special cases. By completeness we mean that it generates a set of polynomial invariants from which, under additional assumptions, any polynomial invariant can be derived. These techniques are implemented in a new software package Aligator written in Mathematica and successfully tried on many programs implementing interesting algorithms working on numbers.

No abstract