THE CONJUGATE FORMAL PRODUCT

Let G be a simple graph of order n and let V (G) be its vertex set. Let c = a + b √ m and c = a − b √ m, where a and b are two nonzero integers and m is a positive integer such that m is not a perfect square. We say that A c = [cij] is the conjugate adjacency matrix of the graph G if cij = c for any two adjacent vertices i and j, cij = c for any two nonadjacent vertices i and j, and cij = 0 if i = j. Let P c G(λ) = |λI − A c | denote the conjugate characteristic polynomial of G and let [A c ij] = {λI −A c}, where {M} denotes the adjoint matrix of a square matrix M. For any two subsets X, Y ⊆ V (G) define 〈X, Y 〉 c = � � A c ij. The expression 〈X, Y 〉 c is called the conjugate i∈X j∈Y formal product of the sets X and Y, associated with the graph G. Using the conjugate formal product we continue our previous investigations of some properties of the conjugate characteristic polynomial of G. 1

Numerical Abstract Domains

Abstract This article presents the systematic design of a class of relational numerical abstract domains from non-relational ones. Constructed domains represent sets of invariants of the form (vj \Gamma vi 2 C), where vj and vi are two variables, and C lives in an abstraction of P(Z), P(Q), or P(R). We will call this family of domains weakly relational domains. The underlying concept allowing this construction is an extension of potential graphs and shortest-path closure algorithms in exotic-like algebras. Example constructions are given in order to retrieve well-known domains as well as new ones. Such domains can then be used in the Abstract Interpretation framework in order to design various static analyses. A major benefit of this construction is its modularity, allowing to quickly implement new abstract domains from existing ones. 1 Introduction Proving the correctness of a program is essential, especially for critical and embedded applications (such as planes, rockets, and so on). Among several correctness criteria, one should ensure that a program can never perform a run-time error (divide by zero, overflow, etc.). A classical method consists in finding a safety invariant before each dangerous operation in the program, and checking that the invariant implies the good behavior of the subsequent operation. Because this task is to be performed on the whole program--containing maybe tens of thousands of lines--and must be repeated after even the slightest code modification, we need a purely automatic static analysis approach