A New Numerical Abstract Domain
Based on Difference-Bound Matrices

arXiv:cs/0703073v2 [] 16 Mar 2007

Antoine Miné
École Normale Supérieure de Paris, France,
mine@di.ens.fr,
http://www.di.ens.fr/~ mine

Abstract. This paper presents a new numerical abstract domain for
static analysis by abstract interpretation. This domain allows us to represent invariants of the form (x − y ≤ c) and (±x ≤ c), where x and y
are variables values and c is an integer or real constant.
Abstract elements are represented by Difference-Bound Matrices, widely
used by model-checkers, but we had to design new operators to meet the
needs of abstract interpretation. The result is a complete lattice of infinite
height featuring widening, narrowing and common transfer functions.
We focus on giving an efficient O(n2 ) representation and graph-based
O(n3 ) algorithms—where n is the number of variables—and claim that
this domain always performs more precisely than the well-known interval
domain.
To illustrate the precision/cost tradeoff of this domain, we have implemented simple abstract interpreters for toy imperative and parallel languages which allowed us to prove some non-trivial algorithms correct.

1

Introduction

Abstract interpretation has proved to be a useful tool for eliminating bugs in software because it allows the design of automatic and sound analyzers for real-life
programming languages. While abstract interpretation is a very general framework, we will be interested here only in discovering numerical invariants, that is
to say, arithmetic relations that hold between numerical variables in a program.
Such invariants are useful for tracking common errors such as division by zero
and out-of-bound array access.
In this paper we propose practical algorithms to discover invariants of the
form (x − y ≤ c) and (±x ≤ c)—where x and y are numerical program variables
and c is a numeric constant. Our method works for integers, reals and even
rationals.
For the sake of brevity, we will omit proofs of theorems in this paper. The
complete proof for all theorems can be found in the author’s MS thesis [12].
Previous and Related Work. Static analysis has developed approaches to
automatically find numerical invariants based on numerical abstract domains

representing the form of the invariants we want to find. Famous examples are
the lattice of intervals (described in, for instance, Cousot and Cousot’s ISOP’76
paper [4]) and the lattice of polyhedra (described in Cousot and Halbwachs’s
POPL’78 paper [8]) which represent respectively invariants of the form (v ∈
[c1 , c2 ]) and (α1 v1 + · · · + αn vn ≤ c). Whereas the interval analysis is very
efficient—linear memory and time cost—but not very precise, the polyhedron
analysis is much more precise but has a huge memory cost—exponential in the
number of variables.
Invariants of the form (x−y ≤ c) and (±x ≤ c) are widely used by the modelchecking community. A special representation, called Difference-Bound Matrices
(DBMs), was introduced, as well as many operators in order to model-check
timed automata (see Yovine’s ES’98 paper [14] and Larsen, Larsson, Pettersson
and Yi’s RTSS’97 paper [10]). Unfortunately, most operators are tied to modelchecking and are of little interest for static analysis.
Our Contribution. This paper presents a new abstract numerical domain
based on the DBM representation, together with a full set of new operators and
transfer functions adapted to static analysis.
Sections 2 and 3 present a few well-known results about potential constraint
sets and introduce briefly the Difference-Bound Matrices. Section 4 presents operators and transfer functions that are new—except for the intersection operator—
and adapted to abstract interpretation. In Section 5, we use these operators to
build lattices, which can be complete under certain conditions. Section 6 shows
some practical results we obtained with an example implementation and Section
7 gives some ideas for improvement.

2

Difference-Bound Matrices

Let V = {v1 , . . . , vn } be a finite set a variables with value in a numerical set I
(which can be the set Z of integers, the set Q of rationals or the set R of reals).
We focus, in this paper, on the representation of constraints of the form
(vj − vi ≤ c), (vi ≤ c) and (vi ≥ c), where vi , vj ∈ V and c ∈ I. By choosing one
variable to be always equal to 0, we can represent the above constraints using only
potential constraints, that is to say, constraints of the form (vj − vi ≤ c). From
now, we will choose v2 , . . . , vn to be program variables, and v1 to be the constant
0 so that (vi ≤ c) and (vi ≥ c) are rewritten (vi − v1 ≤ c) and (v1 − vi ≤ −c). We
assume we now work only with potential constraints over the set {v1 , . . . , vn }.
Difference-Bound Matrices. We extend I to I = I∪{+∞} by adding the +∞
element. The standard operations ≤, =, +, min and max are extended to I as
usual (we will not use operations, such as − or ∗, that may lead to indeterminate
forms).
Any set C of potential constraints over V can be represented uniquely by a n×
n matrix in I—provided we assume, without loss of generality, that there does not

exist two potential constraints (vj − vi ≤ c) in C with the same left member and
different right members. The matrix m associated with the potential constraint
set C is called a Difference-Bound Matrix (DBM) and is defined as follows:

△
c
if (vj − vi ≤ c) ∈ C,
mij =
+∞
elsewhere .
Potential Graphs. A DBM m can be seen as the adjacency matrix of a directed
graph G = (V, A, w) with edges weighted in I. V is the set of nodes, A ⊆ V 2 is
the set of edges and w ∈ A 7→ I is the weight function. G is defined by:

(vi , vj ) ∈
/A
if mij = +∞,
(vi , vj ) ∈ A and w(vi , vj ) = mij
if mij 6= +∞ .
We will denote by hi1 , . . . , ik i a finite set of nodes representing a path from
node vi1 to node vik in G. A cycle is a path such that i1 = ik .
V-Domain and V 0 -Domain. We call the V-domain of a DBM m and we
denote by D(m) the set of points in In that satisfy all potential constraints:
△

D(m) = {(x1 , . . . , xn ) ∈ In | ∀i, j, xj − xi ≤ mij } .
Now, remember that the variable v1 has a special semantics: it is always
equal to 0. Thus, it is not the V-domain which is of interest, but the V 0 -domain
(which is a sort of intersection-projection of the V-domain) denoted by D0 (m)
and defined by:
△

D0 (m) = {(x2 , . . . , xn ) ∈ In−1 | (0, x2 , . . . , xn ) ∈ D(m)} .
We will call V-domain and V 0 -domain any subset of In or In−1 which is
respectively the V-domain or the V 0 -domain of some DBM. Figure 1 shows an
example DBM together with its corresponding potential graph, constraint set,
V-domain and V 0 -domain.
P Order. The ≤ order on I induces a point-wise order P on the set of DBMs:
△

m P n ⇐⇒ ∀i, j, mij ≤ nij .
This order is partial. It is also complete if I has least-upper bounds, i.e, if I is R
or Z, but not Q. We will denote by = the associated equality relation which is
simply the matrix equality.
We have m P n =⇒ D0 (m) ⊆ D0 (n) but the converse is not true. In
particular, we do not have D0 (m) = D0 (n) =⇒ m = n (see Figure 2 for a
counter-example).







v2
−v2
v3
(a)


−v3


v2 − v3

≤ 4
≤ −1
≤ 3
≤ −1
≤ 1

v1 v2 v3
v1 +∞ 4
3
(b)
v2 −1 +∞ +∞
v3 −1 1 +∞

v1
−1

4

(c)

−1

v2

v3

3

1

000000000000
111111111111
1010
000000000000
111111111111
000000000000000
111111111111111
000000000
111111111
000000000000
111111111111
10111111111
000000000
000000000000
111111111111
10111111111
000000000
000000000000
111111111111
10111111111
000000000
(e)
000000000000
111111111111
10111111111
000000000
000000000000
111111111111
10111111111
111111111111111
000000000000000
000000000
000000000000
111111111111
1010
000000000000
111111111111
000000000000
111111111111
1010
000000000000
111111111111
000000000000
111111111111
10

v3

v3

(d)
v1
v2

v2

Fig. 1. A constraint set (a), its corresponding DBM (b) and potential graph (c),
its V-domain (d) and V 0 -domain (e).

(a)

v1 v2 v3
v1 +∞ 4
3
v2 −1 +∞ +∞
v3 −1 1 +∞

(b)

v1 v2 v3
v1 0 5
3
v2 −1 +∞ +∞
v3 −1 1 +∞

(c)

v1 v2 v3
v1 0 4 3
v2 −1 0 +∞
v3 −1 1 0

Fig. 2. Three different DBMs with the same V 0 -domain as in Figure 1. Remark
that (a) and (b) are not even comparable with respect to P.

3

Closure, Emptiness, Inclusion and Equality Tests

We saw in Figure 2 that two different DBMs can represent the same V 0 -domain.
In this section, we show that there exists a normal form for any DBM with a
non-empty V 0 -domain and present an algorithm to find it. The existence and
computability of a normal form is very important since it is, as often in abstract
representations, the key to equality testing used in fixpoint computation. In the
case of DBMs, it will also allows us to carry an analysis of the precision of the
operators defined in the next section.
Emptiness Testing. We have the following graph-oriented theorem:
Theorem 1.
A DBM has an empty V 0 -domain if and only if there exists, in its associated
potential graph, a cycle with a strictly negative total weight.

Checking for cycles with a strictly negative weight is done using the well-known
Bellman-Ford algorithm which runs in O(n3 ). This algorithm can be found in
Cormen, Leiserson and Rivest’s classical algorithmics textbook [2, §25.3].
Closure and Normal Form. Let m be a DBM with a non-empty V 0 -domain
and G its associated potential graph. Since G has no cycle with a strictly negative
weight, we can compute its shortest path closure G ∗ , the adjacency matrix of
which will be denoted by m∗ and defined by:

∗ △


 mii = 0,
N
−1
X
∗ △
m
=
min
mik ik+1 if i 6= j .


1≤N
 ij
hi=i1 ,i2 ,...,iN =ji

k=1

The idea of closure relies on the fact that, if hi = i1 , i2 , . . . , iN = ji is a path
PN −1
from vi to vj , then the constraint vj − vi ≤ k=1 mik ik+1 can be derived from
m by adding the potential constraints vik+1 − vik ≤ mik ik+1 , 1 ≤ k ≤ N − 1.
This is an implicit potential constraint which does not appear directly in the
DBM m. When computing the closure, we replace each potential constraint
vj − vi ≤ mij , i 6= j in m by the tightest implicit constraint we can find, and
each diagonal element by 0 (which is indeed the smallest value vi − vi can reach).
In Figure 2 for instance, (c) is the closure of both the (a) and (b) DBMs.
Theorem 2.
1. m∗ = inf P {n | D0 (n) = D0 (m)}.
2. D0 (m) saturates m∗ , that is to say:
∀i, j, such that m∗ij < +∞, ∃(x1 = 0, x2 , . . . , xn ) ∈ D(m), xj − xi = m∗ij .


Theorem 2.1 states that m∗ is the smallest DBM—with respect to P—that
represents a given V 0 -domain, and thus the closed form is a normal form. Theorem 2.2 is a crucial property to prove accuracy of some operators defined in the
next section.
Any shortest-path graph algorithm can be used to compute the closure of
a DBM. We suggest the straightforward Floyd-Warshall, which is described in
Cormen, Leiserson and Rivest’s textbook [2, §26.2], and has a O(n3 ) time cost.
Equality and Inclusion Testing. The case where m or n or both have an
empty V 0 -domain is easy; in all other cases we use the following theorem—which
is a consequence of Theorem 2.1:
Theorem 3.
1. If m and n have non-empty V 0 -domain, D0 (m) = D0 (n) ⇐⇒ m∗ = n∗ .
2. If m and n have non-empty V 0 -domain, D0 (m) ⊆ D0 (n) ⇐⇒ m∗ P n.

Besides emptiness test and closure, we may need, in order to test equality or
inclusion, to compare matrices with respect to the point-wise ordering P. This
can be done with a O(n2 ) time cost.
Projection. We define the projection π|vk (m) of a DBM m with respect to a
variable vk to be the interval containing all possible values of v ∈ I such that
there exists a point (x2 , . . . , xn ) in the V 0 -domain of m with xk = v:
△

π|vk (m) = {x ∈ I | ∃(x2 , . . . , xn ) ∈ D0 (m) such that x = xk } .
The following theorem, which is a consequence of the saturation property of the
closure, gives an algorithmic way to compute the projection:
Theorem 4.
If m has a non-empty V 0 -domain, then π|vk (m) = [−m∗k1 , m∗1k ]
(interval bounds are included only if finite).

4



Operators and Transfer Functions

In this section, we define some operators and transfer functions to be used in
abstract semantics. Except for the intersection operator, they are new. The operators are basically point-wise extensions of the standard operators defined over
the domain of intervals [4].
Most algorithms presented here are either constant time, or point-wise, i.e.,
quadratic time.

Intersection. Let us define the point-wise intersection DBM m ∧ n by:
△

(m ∧ n)ij = min(mij , nij ) .
We have the following theorem:
Theorem 5.
D0 (m ∧ n) = D0 (m) ∩ D0 (n).



stating that the intersection is always exact. However, the resulting DBM is
seldom closed, even if the arguments are closed.

Least Upper Bound. The set of V 0 -domains is not stable by union1 so we
introduce here a union operator which over-approximate its result. We define
the point-wise least upper bound DBM m ∨ n by:
△

(m ∨ n)ij = max(mij , nij ) .
m ∨ n is indeed the least upper bound with respect to the P order. The
following theorem tells us about the effect of this operator on V 0 -domains:
Theorem 6.
1. D0 (m ∨ n) ⊇ D0 (m) ∪ D0 (n).
2. If m and n have non-empty V 0 -domains, then
(m∗ ) ∨ (n∗ ) = inf {o | D0 (o) ⊇ D0 (m) ∪ D0 (n)}
P

and, as a consequence, D0 ((m∗ ) ∨ (n∗ )) is the smallest V 0 -domain (with
respect to the ⊆ ordering) which contains D0 (m) ∪ D0 (n).
3. If m and n are closed, then so is m ∨ n.

Theorem 6.1 states that D0 (m ∨ n) is an upper bound in the set of V 0 -domains
with respect to the ⊆ order. If precision is a concern, we need to find the least
upper bound in this set. Theorem 6.2—which is a consequence of the saturation
property of the closure—states that we have to close both arguments before
applying the ∨ operator to get this most precise union over-approximation. If
one argument has an empty V 0 -domain, the least upper bound we want is simply
the other argument. Emptiness tests and closure add a O(n3 ) time cost.
1

V 0 -domains are always convex, but the union of two V 0 -domains may not be convex.

Widening. When computing the semantics of a program, one often encounters
loops leading to fixpoint computation involving infinite iteration sequences. In
order to compute in finite time an upper approximation of a fixpoint, widening
operators were introduced in P. Cousot’s thesis [3, §4.1.2.0.4]. Widening is a sort
of union for which every increasing chain is stationary after a finite number of
iterations. We define the point-wise widening operator ▽ by:

△
mij if nij ≤ mij ,
(m▽n)ij =
+∞ elsewhere .
The following properties prove that ▽ is indeed a widening:
Theorem 7.
1. D0 (m▽n) ⊇ D0 (m) ∪ D0 (n).
2. Finite chain property:
∀m and ∀(ni )i∈N , the chain defined by:
(
△
= m,
x0
△

xi+1 = xi ▽ni ,

is increasing for P and ultimately stationary. The limit l is such that l Q m
and ∀i, l Q ni .

The widening operator has some intriguing interactions with closure. Like the
least upper bound, the widening operator gives more precise results if its right
argument is closed, so it is rewarding to change xi+1 = xi ▽ni into xi+1 =
xi ▽(ni ∗ ). This is not the case for the first argument: we can have sometimes
D0 (m▽n)
D0 ((m∗ )▽n). Worse, if we try to force the closure of the first
argument by changing xi+1 = xi ▽ni into xi+1 = (xi ▽ni )∗ , the finite chain
property (Theorem 7.2) is no longer satisfied, as illustrated in Figure 3.
Originally [4], Cousot and Cousot defined widening over intervals ▽ by:
△

[a, b] ▽ [c, d] = [e, f ],
where:
△

e =



a
−∞

if a ≤ c,
elsewhere,

△

f =



b
+∞

if b ≥ d,
elsewhere .

The following theorem proves that the sequence computed by our widening is
always more precise than with the standard widening over intervals:
Theorem 8.
If we have the following iterating sequence:
(
(
△
[y0 , z0 ]
= m∗ ,
x0
△

xk+1 = xk ▽(nk ∗ ),

△

= π|vi (m),
△

[yk+1 , zk+1 ] = [yk , zk ] ▽ π|vi (nk ),

v1

v1
i+1

i+1

1
△

△

m =

ni =

1
1

v2

v3

i+1

v2

1

x2i =

2i+1

v2

x2i+1 =
v3

v1

2i+1

2i
2i

1

v3

1

v1

2i+1

i+1
1

2i+1

v2

1

2i+2
2i+2

1

v3

1

Fig. 3. Example of an infinite strictly increasing chain defined by x0 =
m∗ , xi+1 = (xi ▽ni )∗ .

then the sequence (xk )k∈N is more precise than the sequence ([yk , zk ])k∈N in the
following sense:
∀k, π|vi (xk ) ⊆ [yk , zk ] .

Remark that the technique, described in Cousot and Cousot’s PLILP’92 paper [7], for improving the precision of the standard widening over intervals ▽ can
also be applied to our widening ▽. It allows, for instance, deriving a widening
that always gives better results than a simple sign analysis (which is not the case
of ▽ nor ▽). The resulting widening over DBMs will remain more precise than
the resulting widening over intervals.
Narrowing. Narrowing operators were introduced in P. Cousot’s thesis [3,
§4.1.2.0.11] in order to restore, in a finite time, some information that may
have been lost by widening applications. We define here a point-wise narrowing
operator △ by:

nij
if mij = +∞,
△
(m△n)ij =
mij elsewhere .
The following properties prove that △ is indeed a narrowing:
Theorem 9.
1. If D0 (n) ⊆ D0 (m), then D0 (n) ⊆ D0 (m△n) ⊆ D0 (m).

2. Finite decreasing chain property:
∀m and for any chain (ni )i∈N decreasing for P, the chain defined by:
(
△
= m,
x0
△

xi+1 = xi △ni ,

is decreasing and ultimately stationary.

0

Given a sequence (nk )k∈N such that the chain (D (nk ))k∈N is decreasing
for the ⊆ partial order (but not (nk )k∈N for the P partial order), one way
to ensure the best accuracy as well as the finiteness of the chain (xk )k∈N is
to force the closure of the right argument by changing xi+1 = xi △ni into
xi+1 = xi △(ni ∗ ). Unlike widening, forcing all elements in the chain to be
closed with xi+1 = (xi △ni )∗ poses no problem.
Forget. Given a DBM m and a variable vk , the forget operator m\vk computes a
DBM where all informations about vk are lost. It is the opposite of the projection
operator π|vk . We define this operator by:

 min(mij , mik + mkj ) if i 6= k and j 6= k,
△
0
if i = j = k,
(m\vk )ij =

+∞
elsewhere .

The V 0 -domain of m\vk is obtained by projecting D0 (m) on the subspace
−
→
orthogonal to I−
v→
k , and then extruding the result in the direction of vk :
Theorem 10.
D0 (m\vk ) =
{(x2 , . . . , xn ) ∈ In−1 | ∃x ∈ I, (x2 , . . . , xk−1 , x, xk+1 , . . . , xn ) ∈ D0 (m)}.


Guard. Given an arithmetic equality or inequality g over {v2 , . . . , vn }—which
we call a guard—and a DBM m, the guard transfer function tries to find a new
DBM m(g) the V 0 -domain of which is {s ∈ D0 (m) | s satisfies g}. Since this is,
in general, impossible, we will only try to have:
Theorem 11.
D0 (m(g) ) ⊇ {s ∈ D0 (m) | s satisfies g}.



Here is an example definition:
Definition 12.
1. If g = (vj0 − vi0 ≤ c) with i0 6= j0 , then:

min(mij , c)
△
(m(vj0 −vi0 ≤c) )ij =
mij

if i = i0 and j = j0 ,
elsewhere .

The cases g = (vj0 ≤ c) and g = (−vi0 ≤ c) are settled by choosing respectively i0 = 1 and j0 = 1.

2. If g = (vj0 − vi0 = c) with i0 6= j0 , then:
△

m(vj0 −vi0 =c) = (m(vj0 −vi0 ≤c) )(vi0 −vj0 ≤−c) .
The case g = (vj0 = c) is a special case where i0 = 1.
3. In all other cases, we simply choose:
△

m(g) = m .

In all but the last—general—cases, the guard transfer function is exact.
Assignment. An assignment vk ← e(v2 , . . . , vn ) is defined by a variable vk and
an arithmetic expression e over {v2 , . . . , vn }.
Given a DBM m representing all possible values that can take the variables
set {v2 , . . . , vn } at a program point, we look for a DBM, denoted by m(vk ←e) ,
representing the possibles values of the same variables set after the assignment
vk ← e. This is not possible in the general case, so the assignment transfer
function will only try to find an upper approximation of this set:
Theorem 13.
D0 (m(vk ←e) ) ⊇
{(x2 , . . . , xk−1 , e(x2 , . . . , xn ), xk+1 , . . . , xn ) | (x2 , . . . , xn ) ∈ D0 (m)} .



For instance, we can use the following definition for m(vi0 ←e) :
Definition 14.
1. If e = vi0 + c, then:
(m(vi0 ←vi0 +c) )ij


 mij − c
△
=
mij + c

mij

if i = i0 , j 6= j0 ,
if i 6= i0 , j = j0 ,
elsewhere .

2. If e = vj0 + c with i0 6= j0 , then we use the forget operator and the guard
transfer function:
△

m(vi0 ←vj0 +c) = ((m\vi0 )(vi0 −vj0 ≤c) )(vj0 −vi0 ≤−c) .
The case e = c is a special case where we choose j0 = 1.
3. In all other cases, we use a standard interval arithmetic to find an interval
[−e− , e+ ], e+ , e− ∈ I such that
[−e− , e+ ] ⊇ e(πv2 (m), . . . , πvn (m))
and then we define:
(m(vi0 ←e) )ij

 +
e
△
e−
=

(m\vi0 )ij

if i = 1 and j = i0 ,
if j = 1 and i = i0 ,
elsewhere .


In all but the last—general—cases, the assignment transfer function is exact.

Comparison with the Abstract Domain of Intervals. Most of the time, the
precision of numerical abstract domains can only be compared experimentally
on example programs (see Section 6 for such an example). However, we claim
that the DBM domain always performs better than the domain of intervals.
To legitimate this assertion, we compare informally the effect of all abstract
operations in the DBM and in the interval domains. Thanks to Theorems 5 and
6.2, and Definitions 12 and 14, the intersection and union abstract operators
and the guard and assignment transfer functions are more precise than their
interval counterpart. Thanks to Theorem 8, approximate fixpoint computation
with our widening ▽ is always more accurate than with the standard widening
over intervals ▽ and one could prove easily that each iteration with our narrowing
is more precise than with the standard narrowing over intervals. This means that
any abstract semantics based on the operators and transfer functions we defined
is always more precise than the corresponding interval-based abstract semantics.

5

Lattice Structures

In this section, we design two lattice structures: one on the set of DBMs and one
on the set of closed DBMs. The first one is useful to analyze fixpoint transfer
between abstract and concrete semantics and the second one allows us to design
a meaning function—or even a Galois Connection—linking the set of abstract
V 0 -domains to the concrete lattice P({v2 , . . . , vn } 7→ I), following the abstract
interpretation framework described in Cousot and Cousot’s POPL’79 paper [5].

DBM Lattice. The set M of DBMs, together with the order relation P and the
point-wise least upper bound ∨ and greatest lower bound ∧, is almost a lattice.
It only needs a least element ⊥, so we extend P, ∨ and ∧ to M⊥ = M ∪ {⊥} in
an obvious way to get ⊑, ⊔ and ⊓. The greatest element ⊤ is the DBM with all
its coefficients equal to +∞.
Theorem 15.
1. (M⊥ , ⊑, ⊓, ⊔, ⊥, ⊤) is a lattice.
2. This lattice is complete if (I, ≤) is complete (Z or R, but not Q).

There are, however, two problems with this lattice. First, we cannot easily
assimilate this lattice to a sub-lattice of P({v2 , . . . , vn } 7→ I) as two different
DBMs can have the same V 0 -domain. Then, the least upper bound operator ⊔
is not the most precise upper approximation of the union of two V 0 -domains
because we do not force the arguments to be closed.

Closed DBM Lattice. To overcome these difficulties, we build another lattice
based on closed DBMs. First, consider the set M∗⊥ of closed DBMs M∗ with a
least element ⊥∗ added. Now, we define a greatest element ⊤∗ , a partial order
relation ⊑∗ , a least upper bound ⊔∗ and a greatest lower bound ⊓∗ in M∗⊥ by:

△
0
if i = j,
∗
⊤ ij =
+∞ elsewhere .

△
either m = ⊥∗ ,
∗
m ⊑ n ⇐⇒
or
m 6= ⊥∗ , n 6= ⊥∗ and m P n .

if n = ⊥∗ ,
m
△
∗
m⊔ n =
n
if m = ⊥∗ ,

m ∨ n elsewhere .
 ∗
△
⊥
if m = ⊥∗ or n = ⊥∗ or D0 (m ∧ n) = ∅,
m ⊓∗ n =
∗
(m ∧ n)
elsewhere .
Thanks to Theorem 2.1, every non-empty V 0 -domain has a unique representation in M∗ ; ⊥∗ is the representation for the empty set. We build a meaning
function γ which is an extension of D0 (·) to M∗⊥ :

△
∅
if m = ⊥∗ ,
γ(m) =
0
D (m) elsewhere .
Theorem 16.
1. (M∗⊥ , ⊑∗ , ⊓∗ , ⊔∗ , ⊥∗ , ⊤∗ ) is a lattice and γ is one-to-one.
2. If d
(I, ≤) is complete,
this lattice is complete and γ is meet-preserving:
T
∗
γ( X) = {γ(x) | x ∈ X}. We can—according to Cousot and Cousot [6,
Prop. 7]—build a canonical Galois Insertion:
γ

−−→
−
−− M∗⊥
P({v2 , . . . , vn } 7→ I) ←
−−
−→
α
where the
d abstraction function α is defined by:
α(D) = ∗ { m ∈ M∗⊥ | D ⊆ γ(m) }.

The M∗⊥ lattice features a nice meaning function and a precise union approximation; thus, it is tempting to force all our operators and transfer functions to
live in M∗⊥ by forcing closure on their result. However, we saw this does not work
for widening, so fixpoint computation must be performed in the M⊥ lattice.

6

Results

The algorithms on DBMs presented here have been implemented in OCaml and
used to perform forward analysis on toy—yet Turing-equivalent—imperative and
parallel languages with only numerical variables and no procedure.

We present here neither the concrete and abstract semantics, nor the actual
forward analysis algorithm used for our analyzers. They follow exactly the abstract interpretation scheme described in Cousot and Cousot’s POPL’79 paper
[5] and Bourdoncle’s FMPA’93 paper [1] and are detailed in the author’s MS thesis [12]. Theorems 1, 3, 5, 6, 11 and 13 prove that all the operators and transfer
functions we defined are indeed abstractions on the domain of DBMs of the usual
operators and transfer functions on the concrete domain P({v2 , . . . , vn } 7→ I),
which, as shown by Cousot and Cousot [5], is sufficient to prove soundness for
analyses.
Imperative Programs. Our toy forward analyzer for imperative language follows almost exactly the analyzer described in Cousot and Halbwachs’s POPL’78
paper [8], except that the abstract domain of polyhedra has been replaced by
our DBM-based domain. We tested our analyzer on the well-known Bubble Sort
and Heap Sort algorithms and managed to prove automatically that they do
not produce out-of-bound error while accessing array elements. Although we did
not find as many invariants as Cousot and Halbwachs for these two examples, it
was sufficient to prove the correctness. We do not detail these common examples
here for the sake of brevity.
Parallel Programs. Our toy analyzer for parallel language allows analyzing a
fixed set of processes running concurrently and communicating through global
variables. We use the well-known nondeterministic interleaving method in order
to analyze all possible control flows. In this context, we managed to prove automatically that the Bakery algorithm, introduced in 1974 by Lamport [9], for
synchronizing two parallel processes never lets the two processes be at the same
time in their critical sections. We now detail this example.
The Bakery Algorithm. After the initialization of two global shared variables
y1 and y2, two processes p1 and p2 are spawned. They synchronize through the
variables y1 and y2, representing the priority of p1 and p2, so that only one
process at a time can enter its critical section (Figure 4).
Our analyzer for parallel processes is fed with the initialization code (y1 = 0;
y2 = 0) and the control flow graphs for p1 and p2 (Figure 5). Each control graph
is a set of control point nodes and some edges labeled with either an action
performed when the edge is taken (the assignment y1 ← y2 + 1, for example) or
a guard imposing a condition for taking the edge (the test y1 6= 0, for example).
The analyzer then computes the nondeterministic interleaving of p1 and p2
which is the product control flow graph. Then, it computes iteratively the abstract invariants holding at each product control point. It outputs the invariants
shown in Figure 6.
The state (2, c) is never reached, which means that p1 and p2 cannot be
at the same time in their critical section. This proves the correctness of the
Bakery algorithm. Remark that our analyzer also discovered some non-obvious
invariants, such as y1 = y2 + 1 holding in the (1, c) state.

y1 = 0; y2 = 0;
(p1)
while true do
y1 = y2 + 1;
while y2 6= 0 and y1 > y2 do done;
- - - critical section - - y1 = 0;
done
(p2)
while true do
y2 = y1 + 1;
while y1 6= 0 and y2 ≥ y1 do done;
- - - critical section - - y2 = 0;
done

Fig. 4. Pseudo-code for the Bakery algorithm.

a

0
y1 ← y2 + 1
1
y1 ← 0

y2 6= 0 and y1 > y2
y2 = 0 or y1 ≤ y2

2

y2 ← y1 + 1

critical section

(p1)

b
y2 ← 0

y1 6= 0 and y2 ≥ y1
y1 = 0 or y2 < y1

c

critical section

(p2)

Fig. 5. Control flow graphs of processes p1 and p2 in the Bakery algorithm.

(0, a)
y1 = 0
y2 = 0

(0, b)
y1 = 0
y2 ≥ 1

(0, c)
y1 = 0
y2 ≥ 1

(1, a)
y1 ≥ 1
y2 = 0

(1, b)
y1 ≥ 1
y2 ≥ 1

(1, c)
y1 ≥ 2
y2 ≥ 1
y1 − y2 = 1

(2, a)
y1 ≥ 1
y2 = 0

(2, b)
y1 ≥ 1
y2 ≥ 1
y1 − y2 ∈ [−1, 0]

(2, c)
⊥

Fig. 6. Result of our analyzer on the nondeterministic interleaving product graph
of p1 and p2 in the Bakery algorithm.

7

Extensions and Future Work

Precision improvement. In our analysis, we only find a coarse set of the
invariants held in a program since finding all invariants of the form (x − y ≤ c)
and (±x ≤ c) for all programs is non-computable. Possible losses of precision
have three causes: non-exact union, widening in loops and non-exact assignment
and guard transfer functions.
We made crude approximations in the last—general—case of Definitions 12
and 14 and there is room for improving assignment and guard transfer functions,
even though exactness is impossible. When the DBM lattices are complete, there
exists most precise transfer functions such that Theorems 11 and 13 hold, however these functions may be difficult to compute.
Finite Union of V 0 -domains. One can imagine to represent finite unions of
V 0 -domains, using a finite set of DBMs instead of a single one as abstract state.
This allows an exact union operator but it may lead to memory and time cost
explosion as abstract states contain more and more DBMs, so one may need
from time to time to replace a set of DBMs by their union approximation.
The model-checker community has also developed specific structures to represent finite unions of V-domains, that are less costly than sets. Clock-Difference
Diagrams (introduced in 1999 by Larsen, Weise, Yi and Pearson [11]) and Difference Decision Diagrams (introduced in Møller, Lichtenberg, Andersen and
Hulgaard’s CSL’99 paper [13]) are tree-based structures made compact thanks
to the sharing of isomorphic sub-trees; however existence of normal forms for
such structures is only a conjecture at the time of writing and only local or

path reduction algorithms exist. One can imagine adapting such structures to
abstract interpretation the way we adapted DBM in this paper.

Space and Time Cost Improvement. Space is often a big concern in abstract
interpretation. The DBM representation we proposed in this paper has a fixed
O(n2 ) memory cost—where n is the number of variables in the program. In the
actual implementation, we decided to use the graph representation—or hollow
matrix—which stores only edges with a finite weight and observed a great space
gain as most DBMs we use have many +∞. Most algorithms are also faster
on hollow matrices and we chose to use the more complex, but more efficient,
Johnson shortest-path closure algorithm—described in Cormen, Leiserson and
Rivest’s textbook [2, §26.3]—instead of the Floyd-Warshall algorithm.
Larsen, Larsson, Pettersson and Yi’s RTSS’97 paper [10] presents a minimal
form algorithm which finds a DBM with the fewest finite edges representing a
given V 0 -domain. This minimal form could be useful for memory-efficient storing,
but cannot be used for direct computation with algorithms requiring closed
DBMs.

Representation Improvement. The invariants we manipulate are, in term of
precision and complexity, between interval and polyhedron analysis. It is interesting to look for domains allowing the representation of more forms of invariants
than DBMs in order to increase the granularity of numerical domains. We are
currently working on an improvement of DBMs that allows us to represent, with
a small time and space complexity overhead, invariants of the form (±x± y ≤ c).

8

Conclusion

We presented in this paper a new numerical abstract domain inspired from the
well-known domain of intervals and the Difference-Bound Matrices. This domain
allows us to manipulate invariants of the form (x − y ≤ c), (x ≤ c) and (x ≥ c)
with a O(n2 ) worst case memory cost per abstract state and O(n3 ) worst case
time cost per abstract operation (where n is the number of variables in the
program).
Our approach made it possible for us to prove the correctness of some nontrivial algorithms beyond the scope of interval analysis, for a much smaller cost
than polyhedron analysis. We also proved that this analysis always gives better
results than interval analysis, for a slightly greater cost.

Acknowledgments. I am grateful to J. Feret, C. Hymans, D. Monniaux, P.
Cousot, O. Danvy and the anonymous referees for their helpful comments and
suggestions.

References
[1] F. Bourdoncle. Efficient chaotic iteration strategies with widenings. In FMPA’93,
number 735 in LNCS, pages 128–141. Springer-Verlag, 1993.
[2] T. Cormen, C. Leiserson, and R. Rivest. Introduction to Algorithms. The MIT
Press, 1990.
[3] P. Cousot. Méthodes itératives de construction et d’approximation de points fixes
d’opérateurs monotones sur un treillis, analyse sémantique de programmes. Thèse
d’état ès sciences mathématiques, Université scientifique et médicale de Grenoble,
France, 1978.
[4] P. Cousot and R. Cousot. Static determination of dynamic properties of programs.
In Proc. of the 2d Int. Symposium on Programming, pages 106–130. Dunod, Paris,
France, 1976.
[5] P. Cousot and R. Cousot. Systematic design of program analysis frameworks. In
ACM POPL’79, pages 269–282. ACM Press, 1979.
[6] P. Cousot and R. Cousot. Abstract interpretation and application to logic programs. Journal of Logic Programming, 13(2–3):103–179, 1992.
[7] P. Cousot and R. Cousot. Comparing the Galois connection and widening/narrowing approaches to abstract interpretation, invited paper. In PLILP’92,
number 631 in LNCS, pages 269–295. Springer-Verlag, August 1992.
[8] P. Cousot and N. Halbwachs. Automatic discovery of linear restraints among
variables of a program. In ACM POPL’78, pages 84–97. ACM Press, 1978.
[9] L. Lamport. A new solution of dijkstra’s concurrent programming problem. Communications of the ACM, 8(17):453–455, August 1974.
[10] K. Larsen, F. Larsson, P. Pettersson, and W. Yi. Efficient verification of real-time
systems: Compact data structure and state-space reduction. In IEEE RTSS’97,
pages 14–24. IEEE CS Press, December 1997.
[11] K. Larsen, C. Weise, W. Yi, and J. Pearson. Clock difference diagrams. Nordic
Journal of Computing, 6(3):271–298, October 1999.
[12] A. Miné. Representation of two-variable difference or sum constraint set and application to automatic program analysis. Master’s thesis, ENS-DI, Paris, France,
2000. http://www.eleves.ens.fr:8080/home/mine/stage_dea/.
[13] J. Møller, J. Lichtenberg, R. Andersen, H., and H. Hulgaard. Difference decision
diagrams. In CSL’99, volume 1683 of LNCS, pages 111–125. Springer-Verlag,
September 1999.
[14] S. Yovine. Model-checking timed automata. In Embedded Systems, number 1494
in LNCS, pages 114–152. Springer-Verlag, October 1998.

