Mechanizing Proofs of Termination with Context-Sensitive Dependency Pairs ∗ Ra´ ul Guti´ errez DSIC, Universidad Polit´ ecnica de Valencia Valencia, Spain rgutierrez@dsic.upv.es Salvador Lucas DSIC, Universidad Polit´ ecnica de Valencia Valencia, Spain slucas@dsic.upv.es Abstract The dependency pairs approach, one of the most powerful techniques for proving termination of rewriting, has been recently adapted to be used for proving termination of Context-Sensitive Rewrit- ing (CSR). The notion of Context-Sensitive Dependency Pair (CSDP) is different from the standard one in that collapsing dependency pairs (i.e., rules whose right-hand side is a variable) are consid- ered. Although the implementation and practical use of CSDPs lead to a very powerful framework which improves the current state-of-the-art of methods for proving termination of CSR, handling col- lapsing pairs is not easy and often leads to impose heavy requirements over the base orderings which are used to achieve the proofs. A recent proposal removes collapsing pairs by transforming them into sets of new (standard) pairs. In this way, though, the complexity of the obtained dependency graph is heavily increased and the role of collapsing pairs for modeling context-sensitive computations gets lost. This leads to a less intuitive and accurate description of the termination behavior of the system. In this paper, we show how to get the best of the two approaches, thus obtaining a more powerful dependency pair framework which hopefully fulfills all practical and theoretical expectations. 1 Introduction In Context-Sensitive Rewriting (CSR, [6]), a replacement map μ satisfying μ ( f ) ⊆{1, ..., ar( f )} for every function symbol f in the signature F , is used to discriminate the argument positions on which the rewriting steps are allowed. In this way, a terminating behavior of (context-sensitive) computations with Term Rewriting Systems can be obtained. In [2, 3], Arts and Giesl’s dependency pairs approach was adapted to CSR (see [4] for a more recent presentation). In [1], a transformation that replaces the collapsing dependency pairs (i.e., pairs whose right hand sides are variables, see [2]) by a new set of pairs that simulate their behavior was introduced. This new set of pairs is used to simplify the definition of context-sensitive dependency chain; but, on the other hand, we loose the intuition of what a collapsing pair means in a context-sensitive rewriting chain, and some processors which are based on them cannot be used anymore (see [4]). Furthermore, understanding the new dependency graph is harder. Example 1. Consider the context-sensitive term rewriting system (CS-TRS) in [1] gt(0, y) → false p(0) → 0 gt(s(x), 0) → true p(s(x)) → x gt(s(x), s(y)) → gt(x, y) minus(x, y) → if (gt(y , 0), minus(p(x), p(y)), x) if (true, x, y) → x div(0, s(y)) → 0 if (false, x, y) → y div(s(x), s(y)) → s(div(minus(x, y), s(y))) with μ (if )= {1} and μ ( f )= {1,..., ar( f )} for all other symbols f . If we follow the transformational G. Sutcliffe, A. Voronkov (eds.): easychair 1.0, 2008, volume 1, issue: 1, pp. 1-4 ∗ Supported by the EU (FEDER) and MEC/MICINN projects TIN 2007-68093-C02-02 and TIN 2004-7943-C04-02. 1