29 research outputs found
Proving termination using abstract interpretation
PhDOne way to develop more robust software is to use formal program verification. Formal program
verification requires the construction of a formal mathematical proof of the programs correctness.
In the past ten years or so there has been much progress in the use of automated tools
to formally prove properties of programs. However many such tools focus on proving safety
properties: that something bad does not happen. Liveness properties, where we try to prove
that something good will happen, have received much less attention. Program termination is
an example of a liveness property. It has been known for a long time that to prove program
termination we need to discover some function which maps program states to a well-founded
set. Essentially we need to find one global argument for why the program terminates. Finding
such an argument which overapproximates the entire program is very difficult. Recently, Podelski
and Rybalchenko discovered a more compositional proof rule to find disjunctive termination
arguments. Disjunctive termination arguments requires a series of termination arguments that
individually may only cover part of the program but when put together give a reason for why
the entire program will terminate. Thus we do not need to search for one overall reason for
termination but we can break the problem down and focus on smaller parts of the program.
This thesis develops a series of abstract interpreters for proving the termination of imperative
programs. We make three contributions, each of which makes use of the Podelski-Rybalchenko
result.
Firstly we present a technique to re-use domains and operators from abstract interpreters for
safety properties to produce termination analysers. This technique produces some very fast
termination analysers, but is limited by the underlying safety domain used.
We next take the natural step forward: we design an abstract domain for termination. This
abstract domain is built from ranking functions: in essence the abstract domain only keeps track
of the information necessary to prove program termination. However, the abstract domain is
limited to proving termination for language with iteration.
In order to handle recursion we use metric spaces to design an abstract domain which can handle
recursion over the unit type. We define a framework for designing abstract interpreters for liveness
properties such as termination. The use of metric spaces allows us to model the semantics
of infinite computations for programs with recursion over the unit type so that we can design
an abstract interpreter in a systematic manner. We have to ensure that the abstract interpreter is
well-behaved with respect to the metric space semantics, and our framework gives a way to do
this
Closing the Performance Gap between Doubles and Rationals for Octagons
Octagons have enduring appeal because their domain opera- tions are simple, readily mapping to for-loops which apply max, min and sum to the entries of a Difference Bound Matrix (DBM). In the quest for efficiency, arithmetic is often realised with double-precision floating- point, albeit at the cost of the certainty provided by arbitrary-precision rationals. In this paper we show how Compact DBMs (CoDBMs), which have recently been proposed as a memory refinement for DBMs, enable arithmetic calculation to be short-circuited in various domain operations. We also show how comparisons can be avoided by changing the tables which underpin CoDBMs. From the perspective of implementation, the optimisations are attractive because they too are conceptually simple, following the ethos of Octagons. Yet they can halve the running time on rationals, putting CoDBMs on rationals on a par with DBMs on doubles
Compact Difference Bound Matrices
The Octagon domain, which tracks a restricted class of two variable inequality, is the abstract domain of choice for many applications because its domain operations are either quadratic or cubic in the number of program variables. Octagon constraints are classically represented using a Difference Bound Matrix (DBM), where the entries in the DBM store bounds c for inequalities of the form x_i - x_j <= c, x_i + x_j <= c or -x_i - x_j <= c. The size of such a DBM is quadratic in the number of variables, giving a representation which can be excessively large for number systems such as rationals. This paper proposes a compact representation for DBMs, in which repeated numbers are factored out of the DBM. The paper explains how the entries of a DBM are distributed, and how this distribution can be exploited to save space and significantly speed-up long-running analyses. Moreover, unlike sparse representations, the domain operations retain their conceptually simplicity and ease of implementation whilst reducing memory usage
Incrementally Closing Octagons
The octagon abstract domain is a widely used numeric abstract domain expressing relational information between variables whilst being both computationally efficient and simple to implement. Each element of the domain is a system of constraints where each constraint takes the restricted form ±xi±xj≤c. A key family of operations for the octagon domain are closure algorithms, which check satisfiability and provide a normal form for octagonal constraint systems. We present new quadratic incremental algorithms for closure, strong closure and integer closure and proofs of their correctness. We highlight the benefits and measure the performance of these new algorithms