Usable Rules

The next lemma adapts Lemma 8.3.2 to innermost rewriting.

Lemma 8.3.4. Let t be an innermost terminating term in T (F, V) with root(t) ∈ D.

We have dl(t,−→ⁱ R) = dl(t^♯,−→ⁱ _WIDP(R)∪R).

We conclude this section by discussing the applicability of standard dependency pairs ([9]) in complexity analysis. For that we recall the standard definition of dependency pairs.

Definition 8.3.3 ([9]). The set DP(R) of (standard) dependency pairs of a TRS R is defined as {l^♯→ u^♯| l → r ∈ R, u E r, root(u) ∈ D}.

The following example shows that Lemma 8.3.2 (Lemma 8.3.4) does not hold if we replace weak (innermost) dependency pairs with standard dependency pairs.

Example 8.3.3. Consider the one-rule TRS R: f(s(x)) → g(f(x), f(x)). DP(R) is the singleton of f^♯(s(x)) → f^♯(x). Let t_n = f(sⁿ(x)) for each n > 0. Since t_n+1→Rg(t_n, t_n) holds for all n > 0, it is easy to see dl(t_n+1, →_R) > 2ⁿ, while dl(t^♯_n+1, →_DP(R)∪R) = n.

Hence, in general we cannot replace weak dependency pairs with (standard) depen-dency pairs. However, if we restrict our attention to innermost rewriting, we can employ dependency pairs in complexity analysis without introducing fallacies, when specific conditions are met.

Lemma 8.3.5. Let t be an innermost terminating term with root(t) ∈ D. If all com-pound symbols in WIDP(R) are nullary, dl(t,−→ⁱ R) 6 dl(t^♯,−→ⁱ _DP(R)∪R) + 1 holds.

Example 8.3.4 (continued from Example 8.3.2). The occurring compound symbols are nullary. DP(R) consists of the following two dependency pairs:

append^♯(x, y) → ifappend^♯(x, y, x) ifappend^♯(x, y, u :: v) → append^♯(v, y) .

8.4 Usable Rules

In the previous section, we studied the dependency pair method in the light of complexity analysis. Let R be a TRS and P a set of weak dependency pairs, weak innermost dependency pairs, or standard dependency pairs of R. Lemmata 8.3.2, 8.3.4, and 8.3.5 describe a strong connection between the length of derivations in the original TRSs R and the transformed (and extended) system P ∪ R. In this section we show how we can simplify the new TRS P ∪ R by employing usable rules.

Definition 8.4.1. We write f ⊲_dg if there exists a rewrite rule l → r ∈ R such that f = root(l) and g is a defined function symbol in Fun(r). For a set G of defined function symbols we denote by R↾G the set of rewrite rules l → r ∈ R with root(l) ∈ G. The set U(t) of usable rules of a term t is defined as R↾{g | f ⊲^∗_dg for some f ∈ Fun(t)}.

Finally, if P is a set of (weak) dependency pairs then U(P) =S

l→r∈PU(r).

Example 8.4.1 (continued from Examples 8.3.1 and 8.3.2). The sets of usable rules are empty (and thus equal) for the weak dependency pairs and for the weak innermost dependency pairs, i.e., we have U(WDP(R)) = U(WIDP(R)) = ∅.

The usable rule criterion in termination analysis (cf. [62, 71]) asserts that a non-terminating rewrite sequence of R ∪ DP(R) can be transformed into a non-non-terminating rewrite sequence of U(DP(R)) ∪ DP(R) ∪ {g(x, y) → x, g(x, y) → y}, where g is a fresh function symbol. Because U(DP(R)) is a (small) subset of R and most termination methods can handle g(x, y) → x and g(x, y) → y easily, the termination analysis often becomes easy by switching the target of analysis from the former TRS to the latter TRS. Unfortunately the transformation used in [62, 71] increases the size of starting terms, therefore we cannot adopt this transformation approach. Note, however that the usable rule criteria for innermost termination [57] can be directly applied in the context of complexity analysis. Nevertheless, one may show a new type of usable rule criterion by exploiting the basic property of a starting term. Recall that Tb denotes the set of basic terms; we set T_b^♯ = {t^♯| t ∈ Tb}.

Lemma 8.4.1. Let P be a set of (weak) dependency pairs and let (t_i)_i=0,1,...be a (finite or infinite) derivation of R ∪ P. If t₀∈ T_b^♯ then (t_i)_i=0,1,... is a derivation of U(P) ∪ P.

Proof. Let G be the set of all non-usable symbols with respect to P. We write P (t) if t|_q ∈ N F(R) for all q ∈ PosG(t). Since t_i →_{U (P)∪P} t_i+1 holds whenever P (t_i) and t_i→R∪P t_i+1, it is sufficient to show P (t_i) for all i. We perform induction on i.

(i) Assume i = 0. Since t₀ ∈ T_b^♯, we have t₀ ∈ N F (R) and thus t|p ∈ N F(R) for all positions p. The assertion P follows trivially.

(ii) Suppose i > 0. By induction hypothesis, there exist l → r ∈ U(P) ∪ P, p ∈ Pos(ti−1), and a substitution σ such that t_i−1|p = lσ and t_i|p = rσ. In order to show property P for t_i, we fix a position q ∈ G. We have to show t_i|q ∈ N F (R).

We distinguish three cases:

– Suppose that q is above p. Then t_i−1|_q is reducible, but this contradicts the induction hypothesis P (t_i−1).

– Suppose p and q are parallel but distinct. Since ti−1|q= ti|q∈ N F(R) holds, we obtain P (t_i).

– Otherwise, q is below p. Then, ti|q is a subterm of rσ. Because r contains no G-symbols by the definition of usable symbols, t_i|q is a subterm of xσ for some x ∈ Var(r) ⊆ Var(l). Therefore, t_i|qis also a subterm of t_i−1, from which t_i|_q ∈ N F(R) follows. We obtain P (t_i).

The following theorem follows from Lemmata 8.3.2, 8.3.4, and 8.3.5 in conjunction with the above Lemma 8.4.1. It adapts the usable rule criteria to complexity analysis.³

3Note that Theorem 8.4.1 only holds for basic terms t ∈ T_b^♯. In order to show this, we need some additional technical lemmas, which are the subject of the next section.

8.4 Usable Rules

Theorem 8.4.1. Let R be a TRS and let t ∈ T_b. If t is terminating with respect to → then dl(t, →) 6 dl(t^♯, →_{U (P) ∪ P}), where → denotes →_R or −→ⁱ _R depending on whether P = WDP(R) or P = WIDP(R). Moreover, suppose all compound symbols in WIDP(R) are nullary then dl(t,−→ⁱ R) 6 dl(t^♯, →U (DP(R)) ∪ DP(R)) + 1.

It is worth stressing that it is (often) easier to analyse the complexity of U(P) ∪ P than the complexity of R. To clarify the applicability of the theorem in complexity analysis, we consider two restrictive classes of polynomial interpretations, whose definitions are motivated by [26].

A polynomial P (x₁, . . . , x_n) (over the natural numbers) is called strongly linear if P (x₁, . . . , x_n) = x₁+· · ·+x_n+c where c ∈ N. A polynomial interpretation is called linear restricted if all constructor symbols are interpreted by strongly linear polynomials and all other function symbols by a linear polynomial. If on the other hand the non-constructor symbols are interpreted by quadratic polynomials, the polynomial interpretation is called quadratic restricted. Here a polynomial is quadratic if it is a sum of monomials of degree at most 2. It is easy to see that if a TRS R is compatible with a linear or quadratic restricted interpretation, the runtime complexity of R is linear or quadratic, respectively (see also [26]).

Corollary 8.4.1. Let R be a TRS and let P = WDP(R) or P = WIDP(R). If U(P) ∪ P is compatible with a linear or quadratic restricted interpretation, the (innermost) runtime complexity function rc⁽ⁱ⁾_R with respect to R is linear or quadratic, respectively.

Moreover, suppose all compound symbols in WIDP(R) are nullary and U(DP(R)) ∪ DP(R) is compatible with a linear (quadratic) restricted interpretation, then R admits at most linear (quadratic) innermost runtime complexity.

Proof. Let R be a TRS. For simplicity we suppose P = WDP(R) and assume the existence of a linear restricted interpretation A, compatible with U(P) ∪ P. Clearly this implies the well-foundedness of the relation →_{U (P)∪P}, which in turn implies the well-foundedness of →_R, cf. Lemma 8.4.1. Hence Theorem 8.4.1 is applicable and we conclude dl(t, →_R) 6 dl(t^♯, →_WDP(R)∪R). On the other hand, compatibility with A implies that dl(t^♯, →_WDP(R)∪R) = O(|t^♯|). As |t^♯| = |t|, we can combine these equalities to conclude quadratic runtime complexity of R.

The below given example applies Corollary 8.4.1 to the motivating Example 8.1.1 introduced in Section 8.1.

Example 8.4.2 (continued from Example 8.3.1.). We take a quadratic restricted inter-pretation B into N \ {0} with c_B = d_B = nil_B = 1, e_B(x, y) = x + y, x ::_B y = x + y, hd^♯_B(x) = x + 1, tl^♯_B(x) = x + 1, is empty^♯_B(x) = x + 1, append^♯_B(x, y) = x²+ 3x + y + 1, and ifappend^♯_B(x, y, z) = 2x + y + z²+ z. Then B interprets WDP(R) as follows:

5 : 2 > 1 8 : x + y + 1 > y

6 : x + y + 1 > 1 9 : x²+ 3x + y + 1 > 3x + y + x² 7 : x + y + 1 > x 10 : 2x + y + 2 > y

11 : 2x + y + u²+ 2uv + v²+ u + v > u + v²+ 3v + y + 1

Therefore, WDP(R) ⊆ >_B holds. Hence, the runtime complexity of R for full rewriting is linear. (Recall that U(WDP(R)) = ∅.)