Runtime Complexity TRS:
The TRS R consists of the following rules:

prod(xs) → prodIter(xs, s(0))
prodIter(xs, x) → ifProd(isempty(xs), xs, x)
ifProd(true, xs, x) → x
ifProd(false, xs, x) → prodIter(tail(xs), times(x, head(xs)))
plus(0, y) → y
plus(s(x), y) → s(plus(x, y))
times(x, y) → timesIter(x, y, 0, 0)
timesIter(x, y, z, u) → ifTimes(ge(u, x), x, y, z, u)
ifTimes(true, x, y, z, u) → z
ifTimes(false, x, y, z, u) → timesIter(x, y, plus(y, z), s(u))
isempty(nil) → true
isempty(cons(x, xs)) → false
head(nil) → error
head(cons(x, xs)) → x
tail(nil) → nil
tail(cons(x, xs)) → xs
ge(x, 0) → true
ge(0, s(y)) → false
ge(s(x), s(y)) → ge(x, y)
a → b
a → c

Rewrite Strategy: INNERMOST

Renamed function symbols to avoid clashes with predefined symbol.

Runtime Complexity TRS:
The TRS R consists of the following rules:


prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Rewrite Strategy: INNERMOST

Infered types.

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Heuristically decided to analyse the following defined symbols:
prodIter', plus', timesIter', ge'

They will be analysed ascendingly in the following order:
plus' < timesIter'
ge' < timesIter'

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Generator Equations:
_gen_0':s':error'5(0) ⇔ 0'
_gen_0':s':error'5(+(x, 1)) ⇔ s'(_gen_0':s':error'5(x))
_gen_nil':cons'6(0) ⇔ nil'
_gen_nil':cons'6(+(x, 1)) ⇔ cons'(0', _gen_nil':cons'6(x))

The following defined symbols remain to be analysed:
prodIter', plus', timesIter', ge'

They will be analysed ascendingly in the following order:
plus' < timesIter'
ge' < timesIter'

Proved the following rewrite lemma:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)

Induction Base:
prodIter'(_gen_nil':cons'6(0), _gen_0':s':error'5(0)) →RΩ(1)
ifProd'(isempty'(_gen_nil':cons'6(0)), _gen_nil':cons'6(0), _gen_0':s':error'5(0)) →RΩ(1)
ifProd'(true', _gen_nil':cons'6(0), _gen_0':s':error'5(0)) →RΩ(1)
_gen_0':s':error'5(0)

Induction Step:
prodIter'(_gen_nil':cons'6(+(_$n9, 1)), _gen_0':s':error'5(0)) →RΩ(1)
ifProd'(isempty'(_gen_nil':cons'6(+(_$n9, 1))), _gen_nil':cons'6(+(_$n9, 1)), _gen_0':s':error'5(0)) →RΩ(1)
ifProd'(false', _gen_nil':cons'6(+(1, _$n9)), _gen_0':s':error'5(0)) →RΩ(1)
prodIter'(tail'(_gen_nil':cons'6(+(1, _$n9))), times'(_gen_0':s':error'5(0), head'(_gen_nil':cons'6(+(1, _$n9))))) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), times'(_gen_0':s':error'5(0), head'(_gen_nil':cons'6(+(1, _$n9))))) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), times'(_gen_0':s':error'5(0), 0')) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), timesIter'(_gen_0':s':error'5(0), 0', 0', 0')) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), ifTimes'(ge'(0', _gen_0':s':error'5(0)), _gen_0':s':error'5(0), 0', 0', 0')) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), ifTimes'(true', _gen_0':s':error'5(0), 0', 0', 0')) →RΩ(1)
prodIter'(_gen_nil':cons'6(_$n9), 0') →IH
_gen_0':s':error'5(0)

We have rt ∈ Ω(n) and sz ∈ O(n). Thus, we have ircR ∈ Ω(n).

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Lemmas:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)

Generator Equations:
_gen_0':s':error'5(0) ⇔ 0'
_gen_0':s':error'5(+(x, 1)) ⇔ s'(_gen_0':s':error'5(x))
_gen_nil':cons'6(0) ⇔ nil'
_gen_nil':cons'6(+(x, 1)) ⇔ cons'(0', _gen_nil':cons'6(x))

The following defined symbols remain to be analysed:
plus', timesIter', ge'

They will be analysed ascendingly in the following order:
plus' < timesIter'
ge' < timesIter'

Proved the following rewrite lemma:
plus'(_gen_0':s':error'5(_n4826), _gen_0':s':error'5(b)) → _gen_0':s':error'5(+(_n4826, b)), rt ∈ Ω(1 + n4826)

Induction Base:
plus'(_gen_0':s':error'5(0), _gen_0':s':error'5(b)) →RΩ(1)
_gen_0':s':error'5(b)

Induction Step:
plus'(_gen_0':s':error'5(+(_$n4827, 1)), _gen_0':s':error'5(_b4995)) →RΩ(1)
s'(plus'(_gen_0':s':error'5(_$n4827), _gen_0':s':error'5(_b4995))) →IH
s'(_gen_0':s':error'5(+(_$n4827, _b4995)))

We have rt ∈ Ω(n) and sz ∈ O(n). Thus, we have ircR ∈ Ω(n).

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Lemmas:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)
plus'(_gen_0':s':error'5(_n4826), _gen_0':s':error'5(b)) → _gen_0':s':error'5(+(_n4826, b)), rt ∈ Ω(1 + n4826)

Generator Equations:
_gen_0':s':error'5(0) ⇔ 0'
_gen_0':s':error'5(+(x, 1)) ⇔ s'(_gen_0':s':error'5(x))
_gen_nil':cons'6(0) ⇔ nil'
_gen_nil':cons'6(+(x, 1)) ⇔ cons'(0', _gen_nil':cons'6(x))

The following defined symbols remain to be analysed:
ge', timesIter'

They will be analysed ascendingly in the following order:
ge' < timesIter'

Proved the following rewrite lemma:
ge'(_gen_0':s':error'5(_n6155), _gen_0':s':error'5(_n6155)) → true', rt ∈ Ω(1 + n6155)

Induction Base:
ge'(_gen_0':s':error'5(0), _gen_0':s':error'5(0)) →RΩ(1)
true'

Induction Step:
ge'(_gen_0':s':error'5(+(_$n6156, 1)), _gen_0':s':error'5(+(_$n6156, 1))) →RΩ(1)
ge'(_gen_0':s':error'5(_$n6156), _gen_0':s':error'5(_$n6156)) →IH
true'

We have rt ∈ Ω(n) and sz ∈ O(n). Thus, we have ircR ∈ Ω(n).

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Lemmas:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)
plus'(_gen_0':s':error'5(_n4826), _gen_0':s':error'5(b)) → _gen_0':s':error'5(+(_n4826, b)), rt ∈ Ω(1 + n4826)
ge'(_gen_0':s':error'5(_n6155), _gen_0':s':error'5(_n6155)) → true', rt ∈ Ω(1 + n6155)

Generator Equations:
_gen_0':s':error'5(0) ⇔ 0'
_gen_0':s':error'5(+(x, 1)) ⇔ s'(_gen_0':s':error'5(x))
_gen_nil':cons'6(0) ⇔ nil'
_gen_nil':cons'6(+(x, 1)) ⇔ cons'(0', _gen_nil':cons'6(x))

The following defined symbols remain to be analysed:
timesIter'

Could not prove a rewrite lemma for the defined symbol timesIter'.

Rules:
prod'(xs) → prodIter'(xs, s'(0'))
prodIter'(xs, x) → ifProd'(isempty'(xs), xs, x)
ifProd'(true', xs, x) → x
ifProd'(false', xs, x) → prodIter'(tail'(xs), times'(x, head'(xs)))
plus'(0', y) → y
plus'(s'(x), y) → s'(plus'(x, y))
times'(x, y) → timesIter'(x, y, 0', 0')
timesIter'(x, y, z, u) → ifTimes'(ge'(u, x), x, y, z, u)
ifTimes'(true', x, y, z, u) → z
ifTimes'(false', x, y, z, u) → timesIter'(x, y, plus'(y, z), s'(u))
isempty'(nil') → true'
isempty'(cons'(x, xs)) → false'
head'(nil') → error'
head'(cons'(x, xs)) → x
tail'(nil') → nil'
tail'(cons'(x, xs)) → xs
ge'(x, 0') → true'
ge'(0', s'(y)) → false'
ge'(s'(x), s'(y)) → ge'(x, y)
a' → b'
a' → c'

Types:
prod' :: nil':cons' → 0':s':error'
prodIter' :: nil':cons' → 0':s':error' → 0':s':error'
s' :: 0':s':error' → 0':s':error'
0' :: 0':s':error'
ifProd' :: true':false' → nil':cons' → 0':s':error' → 0':s':error'
isempty' :: nil':cons' → true':false'
true' :: true':false'
false' :: true':false'
tail' :: nil':cons' → nil':cons'
times' :: 0':s':error' → 0':s':error' → 0':s':error'
head' :: nil':cons' → 0':s':error'
plus' :: 0':s':error' → 0':s':error' → 0':s':error'
timesIter' :: 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ifTimes' :: true':false' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error' → 0':s':error'
ge' :: 0':s':error' → 0':s':error' → true':false'
nil' :: nil':cons'
cons' :: 0':s':error' → nil':cons' → nil':cons'
error' :: 0':s':error'
a' :: b':c'
b' :: b':c'
c' :: b':c'
_hole_0':s':error'1 :: 0':s':error'
_hole_nil':cons'2 :: nil':cons'
_hole_true':false'3 :: true':false'
_hole_b':c'4 :: b':c'
_gen_0':s':error'5 :: Nat → 0':s':error'
_gen_nil':cons'6 :: Nat → nil':cons'

Lemmas:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)
plus'(_gen_0':s':error'5(_n4826), _gen_0':s':error'5(b)) → _gen_0':s':error'5(+(_n4826, b)), rt ∈ Ω(1 + n4826)
ge'(_gen_0':s':error'5(_n6155), _gen_0':s':error'5(_n6155)) → true', rt ∈ Ω(1 + n6155)

Generator Equations:
_gen_0':s':error'5(0) ⇔ 0'
_gen_0':s':error'5(+(x, 1)) ⇔ s'(_gen_0':s':error'5(x))
_gen_nil':cons'6(0) ⇔ nil'
_gen_nil':cons'6(+(x, 1)) ⇔ cons'(0', _gen_nil':cons'6(x))

No more defined symbols left to analyse.

The lowerbound Ω(n) was proven with the following lemma:
prodIter'(_gen_nil':cons'6(_n8), _gen_0':s':error'5(0)) → _gen_0':s':error'5(0), rt ∈ Ω(1 + n8)