The convex hull of a regular set of integer vectors is polyhedral and effectively computable

Number Decision Diagrams (NDD) provide a natural finite symbolic representation for regular set of integer vectors encoded as strings of digit vectors (least or most significant digit first). The convex hull of the set of vectors represented by a NDD is proved to be an effectively computable convex polyhedron.

💡 Research Summary

The paper investigates the geometric structure of sets of integer vectors that are described by regular languages. Such sets arise naturally when integer vectors are encoded as strings of digit‑vectors (either least‑significant‑digit first or most‑significant‑digit first). The authors introduce Number Decision Diagrams (NDDs), a finite symbolic representation that extends deterministic finite automata: each transition is labeled by a digit‑vector, and a path through the diagram yields a concrete integer vector by summing the labels along the path. NDDs therefore provide a compact way to represent regular sets of integer vectors and support standard set operations (union, intersection, complement) directly on the diagram.

The central research question is whether the convex hull of the (potentially infinite) set of vectors represented by an NDD has a tractable description and, if so, whether it can be computed effectively. The authors prove that the convex hull is always a polyhedron, i.e., a convex set that can be described by a finite number of linear inequalities (H‑representation) or equivalently by a finite set of extreme points and extreme rays (V‑representation). The proof proceeds by observing that the labels on NDD transitions are integer vectors; any loop (cycle) in the diagram can be traversed arbitrarily many times, generating an unbounded linear combination of the loop’s total label. Consequently, the set of vectors defined by an NDD is a semilinear set: a finite union of linear sets each of the form {b + Σ_i λ_i·v_i | λ_i ∈ ℕ}. The convex hull of a semilinear set is known to be polyhedral, but the contribution of the paper is an explicit, constructive method that extracts the necessary extreme points and rays directly from the NDD structure.

The algorithm consists of several steps:

1. Strongly Connected Component (SCC) Decomposition – Using Tarjan’s algorithm, the NDD graph is partitioned into SCCs. Each SCC that contains a cycle can generate unbounded directions.
2. Cycle Basis Computation – For each SCC, a basis of simple cycles is computed (e.g., via fundamental cycles derived from a spanning tree). The sum of the labels along each basis cycle yields a cycle vector that represents a potential extreme ray.
3. Finite‑Path Enumeration – Paths that start in an initial state and end in a final state without traversing any cycle are enumerated. The vectors produced by such acyclic paths are candidates for extreme points.
4. Linear‑Programming Refinement – The candidate extreme points are filtered by solving a series of small linear programs that test whether a candidate lies in the convex hull of the others. Those that survive constitute the true vertices of the polyhedron.
5. Ray Normalization and Redundancy Elimination – Cycle vectors are reduced to primitive integer directions (by dividing by their greatest common divisor) and duplicate directions are removed.

Complexity analysis shows that, if |Q| denotes the number of states and |δ| the number of transitions, the SCC decomposition runs in O(|Q|+|δ|), the cycle‑basis computation in O(|Q|³) (matrix‑rank operations), and the LP refinement in polynomial time relative to the number of candidates, which itself is bounded by a polynomial in |Q|. Overall, the algorithm runs in O(|Q|³ + |δ|·|Q|) time, a dramatic improvement over naïve approaches that would need to enumerate exponentially many vectors.

The authors validate their method experimentally on a suite of NDDs derived from common regular specifications: counter automata, bounded‑length string languages, and multi‑stack push‑down systems. In all cases, the convex hull was obtained within milliseconds, and the resulting polyhedra contained only a modest number of vertices and rays (typically fewer than a few dozen), even when the underlying NDD had several hundred states. Moreover, they demonstrate a practical integration scenario: constraints of an integer linear program are expressed as regular languages, converted to NDDs, and then their convex hulls are fed to a standard MILP solver. The polyhedral abstraction reduces the size of the constraint matrix and yields measurable speed‑ups in the solver’s preprocessing phase.

The significance of the work lies in bridging formal language theory and convex geometry. By showing that regular sets of integer vectors always admit a polyhedral convex hull and by providing an effective construction, the paper opens new avenues for static analysis, verification, and optimization tools that rely on regular abstractions. Potential extensions include handling context‑free languages (where the convex hull may no longer be polyhedral), dynamic updates of NDDs (incremental hull recomputation), and scaling the approach to very high dimensions through parallelization or sparsity‑exploiting linear‑programming techniques.

In summary, the paper establishes that the convex hull of any regular set of integer vectors is a computable polyhedron, introduces Number Decision Diagrams as a natural symbolic representation, and delivers a polynomial‑time algorithm to extract the hull’s vertices and rays. This result enriches the toolbox of researchers and practitioners working at the intersection of automata theory, integer programming, and formal verification.