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.

💡 Research Summary

The paper addresses the problem of computing the tight closure of a set of integer octagonal (UTVPI) constraints. UTVPI constraints are linear inequalities of the form x ± y ≤ c, where each inequality involves at most two variables. When the variables are required to be integers, the ordinary (real‑valued) closure is insufficient because it does not exploit integrality; a tighter closure—called the tight closure—must be computed to obtain all integer‑implied constraints.

Background and Motivation
UTVPI constraints enjoy a sweet spot between expressive power and algorithmic tractability: many verification and scheduling problems can be encoded using them, and polynomial‑time algorithms exist for basic operations such as satisfiability checking. The core operation for static analysis, however, is the inference of all implied constraints, i.e., the closure. Prior work offered two main families of algorithms. The first uses Bellman‑Ford‑style propagation (O(n·m) time, where n is the number of variables and m the number of constraints) and handles integrality by repeatedly tightening bounds. While theoretically sound, this approach is cumbersome to implement and can suffer from poor performance on dense instances. The second family applies the classic Floyd‑Warshall all‑pairs shortest‑path algorithm to a graph representation of the constraints, achieving O(n³) time. This method, however, computes the real closure and ignores the parity constraints imposed by integer variables, leading to an incomplete set of inferred inequalities.

Contribution
The authors propose a unified O(n³) algorithm that directly yields the tight closure for integer UTVPI constraints. The algorithm consists of three conceptual steps: (1) a graph transformation that encodes each variable xᵢ as two vertices (xᵢ⁺ and xᵢ⁻) representing the positive and negative occurrences; each original inequality xᵢ ± xⱼ ≤ c is translated into two directed edges with weight c, preserving the semantics of the sum or difference; (2) a standard Floyd‑Warshall computation of the minimum distance d(p,q) between every pair of vertices p and q; (3) an integrality correction that forces all distances to be even, because any valid integer bound on xᵢ ± xⱼ must be an even number. Concretely, if d(p,q) is odd, the algorithm replaces it by 2·⌊d(p,q)/2⌋, i.e., it rounds down to the nearest even integer. Finally, the corrected distance matrix is mapped back to a set of UTVPI inequalities, each of the form xᵢ ± xⱼ ≤ c′ where c′ = d(p,q)/2.

Correctness Argument
The paper provides a rigorous proof that the resulting set of inequalities is both sound (it contains the original constraints) and complete (any integer solution of the original system also satisfies all derived inequalities). The soundness follows from the fact that each original inequality appears as a direct edge in the graph, and Floyd‑Warshall never increases distances. Completeness hinges on two observations: (i) any integer solution must respect the parity condition, so the even‑rounded bound is the strongest possible integer bound that does not exclude any feasible solution; (ii) the all‑pairs shortest‑path distances capture the tightest linear combination of original inequalities, and rounding down cannot create a bound that is violated by an integer solution. Hence the algorithm yields the tight closure.

Complexity and Implementation
The dominant cost is the Floyd‑Warshall triple loop, which runs in Θ(n³) time and requires Θ(n²) space for the distance matrix. The parity‑adjustment and reconstruction phases each run in Θ(n²) time, so the overall asymptotic complexity remains Θ(n³). The authors emphasize that the algorithm is conceptually simple: it reuses a well‑known graph routine and adds only a lightweight post‑processing step. This simplicity translates into a small code footprint and ease of integration into existing static‑analysis frameworks.

Experimental Evaluation
To validate practicality, the authors benchmarked their implementation against a state‑of‑the‑art Bellman‑Ford‑based tight‑closure routine on a collection of synthetic and real‑world UTVPI instances (variables ranging from 50 to 200, constraints from 500 to 2000). The results show that the new algorithm consistently matches or outperforms the older method: average runtime reductions of about 20 % on dense instances, comparable memory consumption, and identical closure outputs. The experiments also demonstrate that the algorithm scales gracefully as the number of variables grows, confirming the theoretical O(n³) bound.

Applications and Future Work
Because the tight closure captures all integer‑implied constraints, it can be employed directly in model checking, abstract interpretation, and integer programming preprocessing. The authors suggest several extensions: (a) exploiting sparsity to obtain sub‑cubic performance on large but sparse constraint graphs; (b) developing incremental versions that update the closure efficiently when constraints are added or removed; (c) integrating the technique with other relational abstract domains (e.g., octagons with modular arithmetic).

Conclusion
The paper delivers a clean, provably correct O(n³) algorithm for computing the tight closure of integer octagonal constraints. By marrying the classic Floyd‑Warshall all‑pairs shortest‑path computation with a simple parity‑adjustment step, the authors achieve both theoretical optimality for dense instances and practical ease of implementation. The work bridges a gap between the need for precise integer reasoning in verification tools and the desire for algorithms that are both fast and straightforward to code, opening the door to broader adoption of UTVPI‑based analyses in industry‑scale verification pipelines.