557 research outputs found
Higher-order Program Verification as Satisfiability Modulo Theories with Algebraic Data-types
We report on work in progress on automatic procedures for proving properties
of programs written in higher-order functional languages. Our approach encodes
higher-order programs directly as first-order SMT problems over Horn clauses.
It is straight-forward to reduce Hoare-style verification of first-order
programs into satisfiability of Horn clauses. The presence of closures offers
several challenges: relatively complete proof systems have to account for
closures; and in practice, the effectiveness of search procedures depend on
encoding strategies and capabilities of underlying solvers. We here use
algebraic data-types to encode closures and rely on solvers that support
algebraic data-types. The viability of the approach is examined using examples
from the literature on higher-order program verification
CTL+FO Verification as Constraint Solving
Expressing program correctness often requires relating program data
throughout (different branches of) an execution. Such properties can be
represented using CTL+FO, a logic that allows mixing temporal and first-order
quantification. Verifying that a program satisfies a CTL+FO property is a
challenging problem that requires both temporal and data reasoning. Temporal
quantifiers require discovery of invariants and ranking functions, while
first-order quantifiers demand instantiation techniques. In this paper, we
present a constraint-based method for proving CTL+FO properties automatically.
Our method makes the interplay between the temporal and first-order
quantification explicit in a constraint encoding that combines recursion and
existential quantification. By integrating this constraint encoding with an
off-the-shelf solver we obtain an automatic verifier for CTL+FO
Efficient CTL Verification via Horn Constraints Solving
The use of temporal logics has long been recognised as a fundamental approach
to the formal specification and verification of reactive systems. In this
paper, we take on the problem of automatically verifying a temporal property,
given by a CTL formula, for a given (possibly infinite-state) program. We
propose a method based on encoding the problem as a set of Horn constraints.
The method takes a program, modeled as a transition system, and a property
given by a CTL formula as input. It first generates a set of forall-exists
quantified Horn constraints and well-foundedness constraints by exploiting the
syntactic structure of the CTL formula. Then, the generated set of constraints
are solved by applying an off-the-shelf Horn constraints solving engine. The
program is said to satisfy the property if and only if the generated set of
constraints has a solution. We demonstrate the practical promises of the method
by applying it on a set of challenging examples. Although our method is based
on a generic Horn constraint solving engine, it is able to outperform
state-of-art methods specialised for CTL verification.Comment: In Proceedings HCVS2016, arXiv:1607.0403
Generalised Interpolation by Solving Recursion-Free Horn Clauses
In this paper we present InterHorn, a solver for recursion-free Horn clauses.
The main application domain of InterHorn lies in solving interpolation problems
arising in software verification. We show how a range of interpolation
problems, including path, transition, nested, state/transition and well-founded
interpolation can be handled directly by InterHorn. By detailing these
interpolation problems and their Horn clause representations, we hope to
encourage the emergence of a common back-end interpolation interface useful for
diverse verification tools.Comment: In Proceedings HCVS 2014, arXiv:1412.082
HMC: Verifying Functional Programs Using Abstract Interpreters
We present Hindley-Milner-Cousots (HMC), an algorithm that allows any
interprocedural analysis for first-order imperative programs to be used to
verify safety properties of typed higher-order functional programs. HMC works
as follows. First, it uses the type structure of the functional program to
generate a set of logical refinement constraints whose satisfaction implies the
safety of the source program. Next, it transforms the logical refinement
constraints into a simple first-order imperative program that is safe iff the
constraints are satisfiable. Thus, in one swoop, HMC makes tools for invariant
generation, e.g., based on abstract domains, predicate abstraction,
counterexample-guided refinement, and Craig interpolation be directly
applicable to verify safety properties of modern functional languages in a
fully automatic manner. We have implemented HMC and describe preliminary
experimental results using two imperative checkers -- ARMC and InterProc -- to
verify OCaml programs. Thus, by composing type-based reasoning grounded in
program syntax and state-based reasoning grounded in abstract interpretation,
HMC opens the door to automatic verification of programs written in modern
programming languages.Comment: 12 page
- …