Predicate Pairing for program verification

  title={Predicate Pairing for program verification},
  author={Emanuele DE ANGELIS and Fabio Fioravanti and Alberto Pettorossi and Maurizio Proietti},
  journal={Theory and Practice of Logic Programming},
  pages={126 - 166}
It is well-known that the verification of partial correctness properties of imperative programs can be reduced to the satisfiability problem for constrained Horn clauses (CHCs. [] Key Method model. The converse does not hold in general, and we provide suitable conditions under which the transformed clauses have an 𝓐-definable model if and only if the original ones have an 𝓐-definable model. Then, we present a strategy, called Predicate Pairing, which guides the application of the transformation rules with…
Lemma Generation for Horn Clause Satisfiability: A Preliminary Study
This paper shows how during the process of transforming CHCs for eliminating inductively defined structures one can introduce suitable predicates, called difference predicate, whose definitions correspond to the lemmata to be introduced, and how this can be done by showing the satisfiability of those queries.
Proving Properties of Sorting Programs: A Case Study in Horn Clause Verification
A case study in Horn clause verification is conducted by considering several sorting programs with the aim of exploring the effectiveness of a transformation technique which allows us to eliminate inductive data structures such as lists or trees.
Satisfiability of Constrained Horn Clauses on Algebraic Data Types: A Transformation-based Approach
A new technique for transforming CHCs defined on ADTs into CHCs where the arguments of the predicates have only basic types, such as integers and booleans is proposed, which avoids, during satisfiability checking, the explicit use of proof rules based on induction over the ADTs.
Solving Horn Clauses on Inductive Data Types Without Induction
A transformation technique whose objective is the removal of data structures from CHCs, hence reducing their satisfiability to a satisfiability problem for CHCs on integers and booleans is proposed.
Analysis and Transformation of Constrained Horn Clauses for Program Verification
Analysis and transformation techniques that originate in the field of constraint logic programming (CLP) to the problem of verifying software systems are surveyed and static analysis techniques for CHCs that may be used for inferring relevant program properties, such as loop invariants are described.
Predicate Pairing with Abstraction for Relational Verification
It is studied how the effects of the Predicate Pairing transformation can be enhanced by using various abstract domains based on Linear Arithmetic during the transformation.
Polyvariant Program Specialisation with Property-based Abstraction
Property-based abstraction is shown to be a flexible method of controlling polyvariance in program specialisation in a standard online specialisation algorithm and its application in control flow refinement, verification, termination analysis and dimension-based specialisation is discussed.
Bounded Symbolic Execution for Runtime Error Detection of Erlang Programs
A preliminary work is presented on a tool that, by using the well-known techniques of metaprogramming and symbolic execution, can be used to perform bounded verification of Erlang programs.


Relational Verification Through Horn Clause Transformation
Through an experimental evaluation, it is shown that in many cases CHC solvers are able to prove the satisfiability (or the unsatisfiability) of sets of clauses obtained by applying the transformations proposed, whereas the samesolvers are unable to perform those proofs when given as input the original, untransformed sets of CHCs.
Proving correctness of imperative programs by linearizing constrained Horn clauses
A method for verifying the correctness of imperative programs which is based on the automated transformation of their specifications, and it is shown that several specifications that could not be proved valid by LA-solving methods, can be provedvalid after linearization.
Program verification via iterated specialization
What's Decidable About Arrays?
This work studies a decision procedure for satisfiability in an expressive fragment of a theory of arrays, which is parameterized by the theories of the array elements, and proves that satisfiability is undecidable for several natural extensions to the fragment.
A Rule-based Verification Strategy for Array Manipulating Programs
A method for verifying properties of imperative programs that manipulate integer arrays by encoding the negation of the property of an imperative program prog as a predicate incorrect defined by a CLP program P, and showing that the property holds by proving that incorrect is not a consequence of P.
Semantics-based generation of verification conditions via program specialization
VeriMAP: A Tool for Verifying Programs through Transformations
Experimental results show that VeriMAP is competitive with respect to state-of-the-art tools for program verification.
Simple relational correctness proofs for static analyses and program transformations
We show how some classical static analyses for imperative programs, and the optimizing transformations which they enable, may be expressed and proved correct using elementary logical and…
Horn Clause Solvers for Program Verification
The authors summarize main useful properties of Horn clauses, illustrate encodings of procedural program verification into Horn clauses and then highlight a number of useful simplification strategies at the level of Horn clause.
Regression Verification for Unbalanced Recursive Functions
This work addresses the problem of proving the equivalence of two recursive functions that have different base-cases and/or are not in lock-step, and shows a proof rule for the case of different base cases, based on separating the proof into two parts.