Polynomial Path Orders: A Maximal Model

This paper is concerned with the automated complexity analysis of term rewrite systems (TRSs for short) and the ramification of these in implicit computational complexity theory (ICC for short). We introduce a novel path order with multiset status, the polynomial path order POP*. Essentially relying on the principle of predicative recursion as proposed by Bellantoni and Cook, its distinct feature is the tight control of resources on compatible TRSs: The (innermost) runtime complexity of compatible TRSs is polynomially bounded. We have implemented the technique, as underpinned by our experimental evidence our approach to the automated runtime complexity analysis is not only feasible, but compared to existing methods incredibly fast. As an application in the context of ICC we provide an order-theoretic characterisation of the polytime computable functions. To be precise, the polytime computable functions are exactly the functions computable by an orthogonal constructor TRS compatible with POP*.

💡 Research Summary

The paper tackles the problem of automatically analysing the runtime complexity of term rewrite systems (TRSs) and connects this analysis to implicit computational complexity (ICC). The authors introduce a new reduction order, the Polynomial Path Order POP*, which combines a multiset status with the principle of predicative recursion originally formulated by Bellantoni and Cook. In POP* each function symbol’s arguments are divided into “normal” and “safe” positions; recursive calls are allowed to shrink only the normal arguments while safe arguments remain unchanged. This separation guarantees that the depth of recursion grows at most linearly with the size of the input, thereby enforcing a polynomial bound on the number of innermost rewrite steps.

The order itself is defined by three intertwined components. First, a precedence relation among function symbols determines which symbols are considered larger. Second, a multiset comparison of argument vectors is used, allowing the order to be sensitive to the overall structure of the term rather than to a simple lexicographic comparison. Third, each symbol is assigned a polynomial degree bound; during a rewrite step the degree of the left‑hand side must be at least as large as that of the right‑hand side, ensuring that the cumulative degree never exceeds a fixed polynomial in the input size. Together these constraints form a well‑founded order that can be checked automatically.

The central theoretical contribution is a soundness theorem: any TRS that is compatible with POP* has innermost runtime complexity bounded by O(n^k) for some constant k. The proof proceeds by showing that every recursive call reduces the size of at least one normal argument by a factor that is polynomially related to the original size, and that the multiset‑based comparison prevents any hidden exponential blow‑up in the number of rewrite steps. Consequently, the total length of any innermost reduction sequence is bounded by a polynomial function of the initial term size.

A second major result is an order‑theoretic characterisation of the class of polynomial‑time computable functions. The authors prove that a (total) function is computable in polynomial time if and only if it can be realised by an orthogonal constructor TRS that is compatible with POP*. The “if” direction follows from the soundness theorem, while the “only‑if” direction builds on the known correspondence between predicative recursion and polytime computation, translating the safe‑normal argument discipline into a constructor‑based rewrite system that respects POP*. This yields a clean, order‑based description of the polytime class, complementing existing ICC characterisations based on recursion schemes or type systems.

On the implementation side, the authors encode the POP* compatibility conditions into a SAT problem. Given a TRS, they generate propositional variables for the precedence, degree assignments, and safe/normal argument markings, and then feed the resulting formula to a modern SAT solver. Experiments on standard benchmark suites (TPDB, SRS) demonstrate that the POP*‑based analyser is dramatically faster than competing techniques such as polynomial interpretations, matrix interpretations, or traditional recursive path orders. On average the tool achieves more than a ten‑fold speed‑up while preserving (or improving) the success rate of proving polynomial bounds.

In summary, the paper delivers (1) a novel, multiset‑based reduction order that enforces polynomial runtime bounds via predicative recursion, (2) rigorous proofs that POP* compatibility implies polynomial innermost complexity and that POP* together with orthogonal constructor TRSs exactly captures the polytime computable functions, and (3) an efficient, SAT‑driven implementation that validates the practical feasibility of the approach. The work bridges the gap between automated complexity analysis and ICC, offering a powerful new instrument for both theoretical investigations and real‑world verification of resource‑bounded programs.