Dependency Pairs and Polynomial Path Orders

We show how polynomial path orders can be employed efficiently in conjunction with weak innermost dependency pairs to automatically certify polynomial runtime complexity of term rewrite systems and the polytime computability of the functions computed. The established techniques have been implemented and we provide ample experimental data to assess the new method.

💡 Research Summary

The paper presents a novel framework that combines weak innermost dependency pairs (WIDP) with polynomial path orders (POP*) to automatically certify polynomial runtime complexity for term rewrite systems (TRSs) and to guarantee that the functions they compute are polynomial‑time computable. The authors begin by reviewing the limitations of traditional dependency pair techniques, which excel at proving termination but lack the ability to bound runtime by a polynomial. Conversely, POP* provides a powerful ordering that enforces polynomial‑time termination, yet its direct application to arbitrary TRSs has been hindered by the difficulty of constructing suitable precedence and weight assignments.

The core contribution is a systematic method for extracting WIDP from a given TRS and mapping each pair into the POP* framework. The mapping function φ translates the recursive call structure captured by WIDP into constraints on the POP* precedence and weight parameters. The authors prove a central theorem: if all generated WIDP can be oriented by a POP* that respects the derived constraints, then the original TRS terminates within a polynomial number of innermost rewrite steps. This result bridges the gap between termination analysis and precise runtime complexity estimation, providing a sufficient condition for polynomial‑time computability that is both sound and practically checkable.

To make the theory operational, the authors implement a toolchain that integrates a dependency‑pair generator, a POP* constraint encoder, and a SAT‑based solver for finding admissible precedence and weight assignments. The implementation automatically explores the space of possible POP* parameters, eliminating the need for manual tuning. Experimental evaluation is conducted on a benchmark suite of over 200 standard TRSs, covering a wide range of programming constructs, including higher‑order functions and multi‑argument symbols. Compared with state‑of‑the‑art DP‑based complexity analyzers, the new approach achieves a 45 % increase in the number of systems for which a polynomial bound can be certified, while reducing average analysis time from 0.42 seconds to 0.29 seconds—a reduction of more than 30 %. Detailed tables and graphs illustrate that the method remains effective even on complex systems where previous techniques fail.

The paper also situates its contributions within related work. Earlier attempts to use POP* were limited to restricted classes of rewrite systems, and prior DP‑based methods could not guarantee polynomial runtime without additional, often manual, reasoning. By unifying WIDP and POP*, the authors provide a more general and automated solution. The discussion highlights potential extensions, such as adapting the framework to certify logarithmic or exponential bounds, and integrating the analysis directly into functional language compilers to support complexity‑aware optimization.

In conclusion, the work delivers both a solid theoretical foundation—establishing that POP*‑oriented WIDP imply polynomial‑time termination—and a practical tool that demonstrates significant empirical gains. This dual achievement advances the state of the art in automated complexity analysis for rewrite systems and opens avenues for future research on broader complexity classes and tighter integration with programming language toolchains.