Static Dependency Pair Method based on Strong Computability for Higher-Order Rewrite Systems

Higher-order rewrite systems (HRSs) and simply-typed term rewriting systems (STRSs) are computational models of functional programs. We recently proposed an extremely powerful method, the static dependency pair method, which is based on the notion of strong computability, in order to prove termination in STRSs. In this paper, we extend the method to HRSs. Since HRSs include \lambda-abstraction but STRSs do not, we restructure the static dependency pair method to allow \lambda-abstraction, and show that the static dependency pair method also works well on HRSs without new restrictions.

💡 Research Summary

The paper presents a novel termination‑proving technique for higher‑order rewrite systems (HRSs) called the static dependency pair (SDP) method based on strong computability. While a similar method had been successfully applied to simply‑typed term rewriting systems (STRSs), extending it to HRSs is non‑trivial because HRSs allow λ‑abstraction and higher‑order variables in rule right‑hand sides. The authors address these challenges by (1) redefining static dependency pairs so that they can be extracted from terms containing λ‑abstractions, (2) introducing the notion of plain function‑passing (PFP) as a mild syntactic restriction that guarantees the safety of the extracted pairs, and (3) leveraging the concept of strong computability (SC) as a theoretical foundation for soundness.

Strong computability, originally devised for typed λ‑calculus, is a stricter property than mere termination: a term of basic type is strongly computable iff it is terminating, and a term of functional type is strongly computable precisely when it maps any strongly computable argument to a strongly computable result. The paper proves several key lemmas about SC, notably that SC is preserved under application and λ‑abstraction, and that a non‑SC term can be exposed by applying suitable strongly computable arguments.

The PFP restriction requires that every higher‑order variable occurring on the left‑hand side of a rule appears on the right‑hand side only as a direct argument (possibly truncated) of a safe subterm of the left‑hand side. The authors formalise “safe(l)”, the set of subterms of a left‑hand side l that are guaranteed to be of basic type and therefore strongly computable. Lemma 4.3 shows that if a rule’s left‑hand side instantiated with a substitution yields a term whose arguments are all strongly computable, then any safe subterm of the left‑hand side also becomes strongly computable under the same substitution.

Static dependency pairs are generated by marking every defined symbol (i.e., a symbol occurring as the head of a left‑hand side) in the right‑hand side of a rule, even when that symbol appears inside a λ‑abstraction. The resulting pairs have the form s♯ → t♯, where the “♯” indicates that the head symbol is a defined one. Because the method only looks at syntactic dependencies that are visible in the rule definitions, the number of pairs is dramatically smaller than in the dynamic approach. For the illustrative HRS R_sqsum, the dynamic method yields nine pairs and fifteen recursion components, whereas the static method yields only three pairs and three recursion components.

To prove non‑loopingness of each static recursion component, the authors adapt two classic techniques from first‑order termination analysis: the subterm criterion and reduction pairs. The subterm criterion is extended to handle λ‑abstractions and higher‑order types by allowing the comparison of subterms after β‑η normalisation. A reduction pair (≥, >) is defined on terms modulo β‑η reduction; if every static dependency pair respects ≥ and at least one respects >, the component is non‑looping. The paper demonstrates that all three static components of R_sqsum satisfy the subterm criterion, yielding a concise termination proof that the dynamic method cannot achieve.

The main soundness theorem states that for any PFP HRS, if all static dependency pairs are strongly computable and every static recursion component is non‑looping (as shown by either the subterm criterion or a reduction pair), then the whole system is strongly normalising, i.e., every term terminates. Consequently, the SDP method provides a complete termination technique for a broad class of HRSs without imposing the restrictive “strongly linear” or “non‑nested” conditions previously required.

The paper concludes with a discussion of practical implications. The SDP method can be integrated into automated termination provers for functional languages that compile to HRSs, offering a more scalable alternative to dynamic dependency analysis. Future work includes extending the approach to non‑PFP systems, improving automation of the subterm criterion for higher‑order terms, and exploring hybrid static‑dynamic analyses. Overall, the work significantly advances the theory and practice of termination proving for higher‑order rewriting.