We consider the system AotoYamada_05__Ex5TermProof. Alphabet: 0 : [] --> a add : [a * a] --> a fact : [] --> a -> a mult : [] --> a -> a -> a rec : [a -> a -> a * a] --> a -> a s : [a] --> a Rules: add(0, x) => x add(s(x), y) => s(add(x, y)) mult 0 x => 0 mult s(x) y => add(mult x y, y) rec(f, x) 0 => x rec(f, x) s(y) => f s(y) (rec(f, x) y) fact => rec(mult, s(0)) This AFS is converted to an AFSM simply by replacing all free variables by meta-variables (with arity 0). We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): add(0, X) >? X add(s(X), Y) >? s(add(X, Y)) mult 0 X >? 0 mult s(X) Y >? add(mult X Y, Y) rec(F, X) 0 >? X rec(F, X) s(Y) >? F s(Y) (rec(F, X) Y) fact >? rec(mult, s(0)) We use a recursive path ordering as defined in [Kop12, Chapter 5]. Argument functions: [[0]] = _|_ We choose Lex = {} and Mul = {@_{o -> o -> o}, @_{o -> o}, add, fact, mult, rec, s}, and the following precedence: fact > rec > @_{o -> o} > add > mult > @_{o -> o -> o} > s Taking the argument function into account, and fixing the greater / greater equal choices, the constraints can be denoted as follows: add(_|_, X) >= X add(s(X), Y) >= s(add(X, Y)) @_{o -> o}(@_{o -> o -> o}(mult, _|_), X) >= _|_ @_{o -> o}(@_{o -> o -> o}(mult, s(X)), Y) >= add(@_{o -> o}(@_{o -> o -> o}(mult, X), Y), Y) @_{o -> o}(rec(F, X), _|_) > X @_{o -> o}(rec(F, X), s(Y)) > @_{o -> o}(@_{o -> o -> o}(F, s(Y)), @_{o -> o}(rec(F, X), Y)) fact > rec(mult, s(_|_)) With these choices, we have: 1] add(_|_, X) >= X because [2], by (Star) 2] add*(_|_, X) >= X because [3], by (Select) 3] X >= X by (Meta) 4] add(s(X), Y) >= s(add(X, Y)) because [5], by (Star) 5] add*(s(X), Y) >= s(add(X, Y)) because add > s and [6], by (Copy) 6] add*(s(X), Y) >= add(X, Y) because add in Mul, [7] and [10], by (Stat) 7] s(X) > X because [8], by definition 8] s*(X) >= X because [9], by (Select) 9] X >= X by (Meta) 10] Y >= Y by (Meta) 11] @_{o -> o}(@_{o -> o -> o}(mult, _|_), X) >= _|_ by (Bot) 12] @_{o -> o}(@_{o -> o -> o}(mult, s(X)), Y) >= add(@_{o -> o}(@_{o -> o -> o}(mult, X), Y), Y) because [13], by (Star) 13] @_{o -> o}*(@_{o -> o -> o}(mult, s(X)), Y) >= add(@_{o -> o}(@_{o -> o -> o}(mult, X), Y), Y) because @_{o -> o} > add, [14] and [22], by (Copy) 14] @_{o -> o}*(@_{o -> o -> o}(mult, s(X)), Y) >= @_{o -> o}(@_{o -> o -> o}(mult, X), Y) because @_{o -> o} in Mul, [15] and [21], by (Stat) 15] @_{o -> o -> o}(mult, s(X)) > @_{o -> o -> o}(mult, X) because [16], by definition 16] @_{o -> o -> o}*(mult, s(X)) >= @_{o -> o -> o}(mult, X) because @_{o -> o -> o} in Mul, [17] and [18], by (Stat) 17] mult >= mult by (Fun) 18] s(X) > X because [19], by definition 19] s*(X) >= X because [20], by (Select) 20] X >= X by (Meta) 21] Y >= Y by (Meta) 22] @_{o -> o}*(@_{o -> o -> o}(mult, s(X)), Y) >= Y because [21], by (Select) 23] @_{o -> o}(rec(F, X), _|_) > X because [24], by definition 24] @_{o -> o}*(rec(F, X), _|_) >= X because [25], by (Select) 25] rec(F, X) @_{o -> o}*(rec(F, X), _|_) >= X because [26] 26] rec*(F, X, @_{o -> o}*(rec(F, X), _|_)) >= X because [27], by (Select) 27] X >= X by (Meta) 28] @_{o -> o}(rec(F, X), s(Y)) > @_{o -> o}(@_{o -> o -> o}(F, s(Y)), @_{o -> o}(rec(F, X), Y)) because [29], by definition 29] @_{o -> o}*(rec(F, X), s(Y)) >= @_{o -> o}(@_{o -> o -> o}(F, s(Y)), @_{o -> o}(rec(F, X), Y)) because [30], by (Select) 30] rec(F, X) @_{o -> o}*(rec(F, X), s(Y)) >= @_{o -> o}(@_{o -> o -> o}(F, s(Y)), @_{o -> o}(rec(F, X), Y)) because [31] 31] rec*(F, X, @_{o -> o}*(rec(F, X), s(Y))) >= @_{o -> o}(@_{o -> o -> o}(F, s(Y)), @_{o -> o}(rec(F, X), Y)) because rec > @_{o -> o}, [32] and [39], by (Copy) 32] rec*(F, X, @_{o -> o}*(rec(F, X), s(Y))) >= @_{o -> o -> o}(F, s(Y)) because rec > @_{o -> o -> o}, [33] and [35], by (Copy) 33] rec*(F, X, @_{o -> o}*(rec(F, X), s(Y))) >= F because [34], by (Select) 34] F >= F by (Meta) 35] rec*(F, X, @_{o -> o}*(rec(F, X), s(Y))) >= s(Y) because [36], by (Select) 36] @_{o -> o}*(rec(F, X), s(Y)) >= s(Y) because [37], by (Select) 37] s(Y) >= s(Y) because s in Mul and [38], by (Fun) 38] Y >= Y by (Meta) 39] rec*(F, X, @_{o -> o}*(rec(F, X), s(Y))) >= @_{o -> o}(rec(F, X), Y) because [40], by (Select) 40] @_{o -> o}*(rec(F, X), s(Y)) >= @_{o -> o}(rec(F, X), Y) because @_{o -> o} in Mul, [41] and [44], by (Stat) 41] rec(F, X) >= rec(F, X) because rec in Mul, [42] and [43], by (Fun) 42] F >= F by (Meta) 43] X >= X by (Meta) 44] s(Y) > Y because [45], by definition 45] s*(Y) >= Y because [38], by (Select) 46] fact > rec(mult, s(_|_)) because [47], by definition 47] fact* >= rec(mult, s(_|_)) because fact > rec, [48] and [49], by (Copy) 48] fact* >= mult because fact > mult, by (Copy) 49] fact* >= s(_|_) because fact > s and [50], by (Copy) 50] fact* >= _|_ by (Bot) We can thus remove the following rules: rec(F, X) 0 => X rec(F, X) s(Y) => F s(Y) (rec(F, X) Y) fact => rec(mult, s(0)) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): add(0, X) >? X add(s(X), Y) >? s(add(X, Y)) mult(0, X) >? 0 mult(s(X), Y) >? add(mult(X, Y), Y) We use a recursive path ordering as defined in [Kop12, Chapter 5]. We choose Lex = {} and Mul = {0, add, mult, s}, and the following precedence: mult > add > s > 0 With these choices, we have: 1] add(0, X) > X because [2], by definition 2] add*(0, X) >= X because [3], by (Select) 3] X >= X by (Meta) 4] add(s(X), Y) > s(add(X, Y)) because [5], by definition 5] add*(s(X), Y) >= s(add(X, Y)) because add > s and [6], by (Copy) 6] add*(s(X), Y) >= add(X, Y) because add in Mul, [7] and [10], by (Stat) 7] s(X) > X because [8], by definition 8] s*(X) >= X because [9], by (Select) 9] X >= X by (Meta) 10] Y >= Y by (Meta) 11] mult(0, X) >= 0 because [12], by (Star) 12] mult*(0, X) >= 0 because mult > 0, by (Copy) 13] mult(s(X), Y) >= add(mult(X, Y), Y) because [14], by (Star) 14] mult*(s(X), Y) >= add(mult(X, Y), Y) because mult > add, [15] and [20], by (Copy) 15] mult*(s(X), Y) >= mult(X, Y) because mult in Mul, [16] and [19], by (Stat) 16] s(X) > X because [17], by definition 17] s*(X) >= X because [18], by (Select) 18] X >= X by (Meta) 19] Y >= Y by (Meta) 20] mult*(s(X), Y) >= Y because [19], by (Select) We can thus remove the following rules: add(0, X) => X add(s(X), Y) => s(add(X, Y)) We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): mult(0, X) >? 0 mult(s(X), Y) >? add(mult(X, Y), Y) We use a recursive path ordering as defined in [Kop12, Chapter 5]. Argument functions: [[0]] = _|_ We choose Lex = {} and Mul = {add, mult, s}, and the following precedence: s > mult > add Taking the argument function into account, and fixing the greater / greater equal choices, the constraints can be denoted as follows: mult(_|_, X) > _|_ mult(s(X), Y) >= add(mult(X, Y), Y) With these choices, we have: 1] mult(_|_, X) > _|_ because [2], by definition 2] mult*(_|_, X) >= _|_ by (Bot) 3] mult(s(X), Y) >= add(mult(X, Y), Y) because [4], by (Star) 4] mult*(s(X), Y) >= add(mult(X, Y), Y) because mult > add, [5] and [10], by (Copy) 5] mult*(s(X), Y) >= mult(X, Y) because mult in Mul, [6] and [9], by (Stat) 6] s(X) > X because [7], by definition 7] s*(X) >= X because [8], by (Select) 8] X >= X by (Meta) 9] Y >= Y by (Meta) 10] mult*(s(X), Y) >= Y because [9], by (Select) We can thus remove the following rules: mult(0, X) => 0 We use rule removal, following [Kop12, Theorem 2.23]. This gives the following requirements (possibly using Theorems 2.25 and 2.26 in [Kop12]): mult(s(X), Y) >? add(mult(X, Y), Y) We use a recursive path ordering as defined in [Kop12, Chapter 5]. We choose Lex = {} and Mul = {add, mult, s}, and the following precedence: s > mult > add With these choices, we have: 1] mult(s(X), Y) > add(mult(X, Y), Y) because [2], by definition 2] mult*(s(X), Y) >= add(mult(X, Y), Y) because mult > add, [3] and [8], by (Copy) 3] mult*(s(X), Y) >= mult(X, Y) because mult in Mul, [4] and [7], by (Stat) 4] s(X) > X because [5], by definition 5] s*(X) >= X because [6], by (Select) 6] X >= X by (Meta) 7] Y >= Y by (Meta) 8] mult*(s(X), Y) >= Y because [7], by (Select) We can thus remove the following rules: mult(s(X), Y) => add(mult(X, Y), Y) All rules were succesfully removed. Thus, termination of the original system has been reduced to termination of the beta-rule, which is well-known to hold. +++ Citations +++ [Kop12] C. Kop. Higher Order Termination. PhD Thesis, 2012.