Termination Proofs in the Dependency Pair Framework May Induce Multiple Recursive Derivational Complexity

We study the derivational complexity of rewrite systems whose termination is provable in the dependency pair framework using the processors for reduction pairs, dependency graphs, or the subterm criterion. We show that the derivational complexity of such systems is bounded by a multiple recursive function, provided the derivational complexity induced by the employed base techniques is at most multiple recursive. Moreover we show that this upper bound is tight.

💡 Research Summary

The paper investigates the derivational complexity of term rewriting systems (TRSs) whose termination can be proved within the Dependency Pair Framework (DPF). The DPF, a powerful modular method for termination proofs, transforms potential infinite rewrite sequences into abstract objects called dependency pairs and then analyses the relationships among these pairs using various processors. The three principal processors examined are reduction‑pair processors, dependency‑graph processors, and the subterm‑criterion processor. Each processor relies on an underlying “base technique” – a well‑founded order such as a linear, polynomial, or multiple‑recursive ordering – which itself imposes a bound on the derivational complexity of the rewrite steps it can handle.

The authors first formalise the notion of a base technique’s induced complexity. They assume that the base technique yields a derivational complexity bounded by a multiple‑recursive function (i.e., a function that can be expressed as a finite composition of the primitive recursive hierarchy’s exponential levels). Under this assumption they prove a general upper‑bound theorem: any TRS whose termination is established by a DPF that employs only the three processors mentioned above has its overall derivational complexity bounded by a multiple‑recursive function as well. The proof proceeds in two stages. In the first stage they show that each individual processor, when applied to a TRS, does not increase the complexity beyond the bound supplied by its base technique. This is achieved by constructing a measure that strictly decreases according to the order supplied by the base technique and by demonstrating that the processor’s transformation respects this measure. In the second stage they compose the bounds for a sequence of processor applications. Because the dependency‑graph processor decomposes the dependency pair set into strongly connected components (SCCs) that can be treated independently, the overall bound is essentially the maximum of the bounds for the SCCs, each of which is itself a multiple‑recursive function. Consequently the composition remains within the multiple‑recursive class.

To demonstrate that the bound is tight, the paper presents a family of rewrite systems for which the base technique is extremely weak (e.g., a simple linear order) yet the DPF construction forces the derivational length to grow as a multiple‑recursive function. By carefully designing the rules so that each application of a processor introduces a new level of recursion, the authors obtain systems whose derivational complexity matches the upper bound. This shows that the multiple‑recursive bound cannot be improved in general without restricting the class of processors or the shape of the base techniques.

The significance of the results lies in their clarification of the relationship between termination proofs in the DPF and the quantitative behaviour of the underlying rewrite systems. Prior work had established polynomial or elementary bounds for specific subclasses of DPF proofs, but this paper extends the analysis to the full generality of the three most widely used processors. It reveals that, despite the modular nature of the framework, the complexity can climb to the multiple‑recursive tier, which is substantially higher than elementary or primitive‑recursive levels. For developers of automated termination provers, the theorem provides a concrete guarantee: if the prover’s base techniques are known to be multiple‑recursive, the prover will never encounter a system whose derivational complexity exceeds that class, allowing for more precise resource estimation and for the design of heuristics that avoid unnecessary processor combinations.

Future directions suggested include extending the analysis to newer processors such as usable‑rule or argument‑filtering techniques, investigating lower‑bound constructions for other complexity classes, and integrating the theoretical bounds into practical tools to dynamically adjust proof strategies based on observed complexity growth. Overall, the paper delivers a rigorous, tight characterization of how the Dependency Pair Framework influences derivational complexity, positioning multiple‑recursive functions as the exact upper limit for the class of termination proofs considered.