Generating Program Invariants via Interpolation

This article focuses on automatically generating polynomial equations that are inductive loop invariants of computer programs. We propose a new algorithm for this task, which is based on polynomial interpolation. Though the proposed algorithm is not complete, it is efficient and can be applied to a broader range of problems compared to existing methods targeting similar problems. The efficiency of our approach is testified by experiments on a large collection of programs. The current implementation of our method is based on dense interpolation, for which a total degree bound is needed. On the theoretical front, we study the degree and dimension of the invariant ideal of loops which have no branches and where the assignments define a P-solvable recurrence. In addition, we obtain sufficient conditions for non-trivial polynomial equation invariants to exist (resp. not to exist).

💡 Research Summary

The paper tackles the problem of automatically generating polynomial loop invariants for imperative programs. Traditional approaches rely on symbolic algebra techniques such as Gröbner‑basis computation, recurrence solving, or abstract interpretation. While mathematically complete, these methods often become infeasible when the invariant degree grows or when the program contains many variables, because the underlying algebraic systems explode in size.

The authors propose a fundamentally different strategy: use dense multivariate polynomial interpolation to infer candidate invariants from concrete execution traces. The user supplies a total‑degree bound d for the invariant. Given d, the algorithm enumerates all monomials in the loop variables up to degree d, forming a linear basis for the space of possible invariants. It then runs the target program (or a symbolic simulator) on a set of initial states, collects the values of the loop variables at a fixed program point (typically after each iteration), and constructs a linear system whose unknowns are the coefficients of the monomials. Solving this system (by Gaussian elimination or least‑squares if the system is over‑determined) yields a concrete polynomial candidate.

The candidate is subsequently checked for inductiveness: (1) it must hold on the initial states, and (2) it must be preserved by one loop iteration. If both conditions succeed, the polynomial is a valid inductive invariant. If not, the algorithm either raises the degree bound or gathers additional samples and repeats the interpolation step. Because the method is based on concrete samples, it is not complete: a genuine invariant of degree higher than the supplied bound will never be discovered, and insufficient sampling may lead to spurious solutions that fail the inductiveness test. Nonetheless, the approach is highly efficient in practice, as the bulk of the work reduces to solving a linear system whose size is polynomial in the number of monomials, rather than performing costly Gröbner‑basis reductions.

On the theoretical side, the paper focuses on a class of loops called P‑solvable. A P‑solvable loop is one whose assignments can be expressed as a linear homogeneous recurrence plus a polynomial non‑homogeneous term. For such loops, the authors analyze the structure of the invariant ideal, deriving upper bounds on its degree and on its Krull dimension. They prove that if the dimension of the invariant ideal is strictly smaller than the number of program variables, then non‑trivial polynomial invariants must exist; conversely, when the transition matrix has pairwise distinct eigenvalues, the invariant ideal can be trivial, implying that no non‑constant polynomial invariant exists. These results give sufficient (and in some cases necessary) conditions for the existence of polynomial invariants, which can be used to prune the search space before invoking the interpolation algorithm.

The experimental evaluation comprises a large benchmark of roughly two hundred programs, including real‑world loops extracted from open‑source projects and synthetic loops designed to stress the algorithm. The interpolation‑based method consistently outperforms state‑of‑the‑art Gröbner‑basis tools, often by an order of magnitude in runtime. In particular, for loops requiring invariants of degree four or five, the new algorithm remains tractable while symbolic methods either time out or run out of memory. The authors also demonstrate that modest increases in the degree bound (e.g., from 3 to 5) dramatically increase the number of discovered invariants, confirming the importance of an appropriate bound selection.

In summary, the paper introduces a practical, interpolation‑driven technique for generating polynomial loop invariants. Although it sacrifices completeness, it gains substantial efficiency and applicability to a broader class of programs than existing algebraic methods. The accompanying theoretical analysis of P‑solvable loops provides valuable insight into when polynomial invariants can be expected, and the extensive experimental results validate the approach’s scalability. Future work suggested includes adaptive degree‑bound selection, smarter sampling strategies, and extensions to loops with conditional branches or nondeterministic updates.