143 research outputs found
An Improved Tight Closure Algorithm for Integer Octagonal Constraints
Integer octagonal constraints (a.k.a. ``Unit Two Variables Per Inequality''
or ``UTVPI integer constraints'') constitute an interesting class of
constraints for the representation and solution of integer problems in the
fields of constraint programming and formal analysis and verification of
software and hardware systems, since they couple algorithms having polynomial
complexity with a relatively good expressive power. The main algorithms
required for the manipulation of such constraints are the satisfiability check
and the computation of the inferential closure of a set of constraints. The
latter is called `tight' closure to mark the difference with the (incomplete)
closure algorithm that does not exploit the integrality of the variables. In
this paper we present and fully justify an O(n^3) algorithm to compute the
tight closure of a set of UTVPI integer constraints.Comment: 15 pages, 2 figure
Deciding Conditional Termination
We address the problem of conditional termination, which is that of defining
the set of initial configurations from which a given program always terminates.
First we define the dual set, of initial configurations from which a
non-terminating execution exists, as the greatest fixpoint of the function that
maps a set of states into its pre-image with respect to the transition
relation. This definition allows to compute the weakest non-termination
precondition if at least one of the following holds: (i) the transition
relation is deterministic, (ii) the descending Kleene sequence
overapproximating the greatest fixpoint converges in finitely many steps, or
(iii) the transition relation is well founded. We show that this is the case
for two classes of relations, namely octagonal and finite monoid affine
relations. Moreover, since the closed forms of these relations can be defined
in Presburger arithmetic, we obtain the decidability of the termination problem
for such loops.Comment: 61 pages, 6 figures, 2 table
Exact Join Detection for Convex Polyhedra and Other Numerical Abstractions
Deciding whether the union of two convex polyhedra is itself a convex
polyhedron is a basic problem in polyhedral computations; having important
applications in the field of constrained control and in the synthesis,
analysis, verification and optimization of hardware and software systems. In
such application fields though, general convex polyhedra are just one among
many, so-called, numerical abstractions, which range from restricted families
of (not necessarily closed) convex polyhedra to non-convex geometrical objects.
We thus tackle the problem from an abstract point of view: for a wide range of
numerical abstractions that can be modeled as bounded join-semilattices --that
is, partial orders where any finite set of elements has a least upper bound--,
we show necessary and sufficient conditions for the equivalence between the
lattice-theoretic join and the set-theoretic union. For the case of closed
convex polyhedra --which, as far as we know, is the only one already studied in
the literature-- we improve upon the state-of-the-art by providing a new
algorithm with a better worst-case complexity. The results and algorithms
presented for the other numerical abstractions are new to this paper. All the
algorithms have been implemented, experimentally validated, and made available
in the Parma Polyhedra Library.Comment: 36 pages, 4 figure
Sparsity Preserving Algorithms for Octagons
Known algorithms for manipulating octagons do not preserve their sparsity, leading typically to quadratic or cubic time and space complexities even if no relation among variables is known when they are all bounded. In this paper, we present new algorithms, which use and return octagons represented as weakly closed difference bound matrices, preserve the sparsity of their input and have better performance in the case their inputs are sparse. We prove that these algorithms are as precise as the known ones
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
Vérification relationnelle pour des programmes avec des données entières
Les travaux présentés dans cette thèse sont lies aux problèmes de vérification de l'atteignabilité et de la terminaison de programmes qui manipulent des données entières non-bornées. On décrit une nouvelle méthode de vérification basée sur une technique d'accélération de boucle, qui calcule, de manière exacte, la clôture transitive d'une relation arithmétique. D'abord, on introduit un algorithme d'accélération de boucle qui peut calculer, en quelques secondes, des clôtures transitives pour des relations de l'ordre d'une centaine de variables. Ensuite, on présente une méthode d'analyse de l'atteignabilité, qui manipule des relations entre les variables entières d'un programme, et applique l'accélération pour le calcul des relations entrée-sortie des procédures, de façon modulaire. Une approche alternative pour l'analyse de l'atteignabilité, présentée également dans cette thèse, intègre l'accélération avec l'abstraction par prédicats, afin de traiter le problème de divergence de cette dernière. Ces deux méthodes ont été évaluées de manière pratique, sur un nombre important d'exemples, qui étaient, jusqu'a présent, hors de la portée des outils d'analyse existants. Dernièrement, on a étudié le problème de la terminaison pour certaines classes de boucles de programme, et on a montré la décidabilité pour les relations étudiées. Pour ces classes de relations arithmétiques, on présente un algorithme qui s'exécute en temps au plus polynomial, et qui calcule l'ensemble d'états qui peuvent générer une exécution infinie. Ensuite on a intégré cet algorithme dans une méthode d'analyse de la terminaison pour des programmes qui manipulent des données entières.This work presents novel methods for verification of reachability and termination properties of programs that manipulate unbounded integer data. Most of these methods are based on acceleration techniques which compute transitive closures of program loops. We first present an algorithm that accelerates several classes of integer relations and show that the new method performs up to four orders of magnitude better than the previous ones. On the theoretical side, our framework provides a common solution to the acceleration problem by proving that the considered classes of relations are periodic. Subsequently, we introduce a semi-algorithmic reachability analysis technique that tracks relations between variables of integer programs and applies the proposed acceleration algorithm to compute summaries of procedures in a modular way. Next, we present an alternative approach to reachability analysis that integrates predicate abstraction with our acceleration techniques to increase the likelihood of convergence of the algorithm. We evaluate these algorithms and show that they can handle a number of complex integer programs where previous approaches failed. Finally, we study the termination problem for several classes of program loops and show that it is decidable. Moreover, for some of these classes, we design a polynomial time algorithm that computes the exact set of program configurations from which non-terminating runs exist. We further integrate this algorithm into a semi-algorithmic method that analyzes termination of integer programs, and show that the resulting technique can verify termination properties of several non-trivial integer programs.SAVOIE-SCD - Bib.électronique (730659901) / SudocGRENOBLE1/INP-Bib.électronique (384210012) / SudocGRENOBLE2/3-Bib.électronique (384219901) / SudocSudocFranceF
Trichotomy for Integer Linear Systems Based on Their Sign Patterns
In this paper, we consider solving the integer linear systems, i.e.,
given a matrix A in R^{m*n}, a vector b in R^m, and a positive integer d, to compute an integer vector x in D^n such that Ax <= b,
where m and n denote positive integers, R denotes the set of reals, and D={0,1,..., d-1}. The problem is one of the most fundamental NP-hard problems in computer science.
For the problem, we propose a complexity index h which is based only on the sign pattern of A. For a real r, let ILS_=(r) denote the family of the problem instances I with h(I)=r. We then show the following trichotomy:
- ILS_=(r) is linearly solvable, if r < 1,
- ILS_=(r) is weakly NP-hard and pseudo-polynomially solvable, if r = 1, and
- ILS_=(r) is strongly NP-hard, if r > 1.
This, for example, includes the existing results that quadratic systems and Horn systems can be solved in pseudo-polynomial time
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
- …