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

div(x, y) → div2(x, y, 0)
div2(x, y, i) → if1(le(y, 0), le(y, x), x, y, plus(i, 0), inc(i))
if1(true, b, x, y, i, j) → divZeroError
if1(false, b, x, y, i, j) → if2(b, x, y, i, j)
if2(true, x, y, i, j) → div2(minus(x, y), y, j)
if2(false, x, y, i, j) → i
inc(0) → 0
inc(s(i)) → s(inc(i))
le(s(x), 0) → false
le(0, y) → true
le(s(x), s(y)) → le(x, y)
minus(x, 0) → x
minus(0, y) → 0
minus(s(x), s(y)) → minus(x, y)
plus(x, y) → plusIter(x, y, 0)
plusIter(x, y, z) → ifPlus(le(x, z), x, y, z)
ifPlus(true, x, y, z) → y
ifPlus(false, x, y, z) → plusIter(x, s(y), s(z))
ac

Rewrite Strategy: INNERMOST

Renamed function symbols to avoid clashes with predefined symbol.

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

div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Rewrite Strategy: INNERMOST

Infered types.

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Heuristically decided to analyse the following defined symbols:
div2', le', inc', minus', plusIter'

They will be analysed ascendingly in the following order:
le' < div2'
inc' < div2'
minus' < div2'
le' < plusIter'

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

The following defined symbols remain to be analysed:
le', div2', inc', minus', plusIter'

They will be analysed ascendingly in the following order:
le' < div2'
inc' < div2'
minus' < div2'
le' < plusIter'

Proved the following rewrite lemma:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)

Induction Base:
le'(_gen_0':divZeroError':s'4(+(1, 0)), _gen_0':divZeroError':s'4(0)) →RΩ(1)
false'

Induction Step:
le'(_gen_0':divZeroError':s'4(+(1, +(_\$n7, 1))), _gen_0':divZeroError':s'4(+(_\$n7, 1))) →RΩ(1)
le'(_gen_0':divZeroError':s'4(+(1, _\$n7)), _gen_0':divZeroError':s'4(_\$n7)) →IH
false'

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

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Lemmas:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

The following defined symbols remain to be analysed:
inc', div2', minus', plusIter'

They will be analysed ascendingly in the following order:
inc' < div2'
minus' < div2'

Proved the following rewrite lemma:
inc'(_gen_0':divZeroError':s'4(_n1488)) → _gen_0':divZeroError':s'4(_n1488), rt ∈ Ω(1 + n1488)

Induction Base:
inc'(_gen_0':divZeroError':s'4(0)) →RΩ(1)
0'

Induction Step:
inc'(_gen_0':divZeroError':s'4(+(_\$n1489, 1))) →RΩ(1)
s'(inc'(_gen_0':divZeroError':s'4(_\$n1489))) →IH
s'(_gen_0':divZeroError':s'4(_\$n1489))

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

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Lemmas:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)
inc'(_gen_0':divZeroError':s'4(_n1488)) → _gen_0':divZeroError':s'4(_n1488), rt ∈ Ω(1 + n1488)

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

The following defined symbols remain to be analysed:
minus', div2', plusIter'

They will be analysed ascendingly in the following order:
minus' < div2'

Proved the following rewrite lemma:
minus'(_gen_0':divZeroError':s'4(_n2371), _gen_0':divZeroError':s'4(_n2371)) → _gen_0':divZeroError':s'4(0), rt ∈ Ω(1 + n2371)

Induction Base:
minus'(_gen_0':divZeroError':s'4(0), _gen_0':divZeroError':s'4(0)) →RΩ(1)
_gen_0':divZeroError':s'4(0)

Induction Step:
minus'(_gen_0':divZeroError':s'4(+(_\$n2372, 1)), _gen_0':divZeroError':s'4(+(_\$n2372, 1))) →RΩ(1)
minus'(_gen_0':divZeroError':s'4(_\$n2372), _gen_0':divZeroError':s'4(_\$n2372)) →IH
_gen_0':divZeroError':s'4(0)

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

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Lemmas:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)
inc'(_gen_0':divZeroError':s'4(_n1488)) → _gen_0':divZeroError':s'4(_n1488), rt ∈ Ω(1 + n1488)
minus'(_gen_0':divZeroError':s'4(_n2371), _gen_0':divZeroError':s'4(_n2371)) → _gen_0':divZeroError':s'4(0), rt ∈ Ω(1 + n2371)

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

The following defined symbols remain to be analysed:
div2', plusIter'

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

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Lemmas:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)
inc'(_gen_0':divZeroError':s'4(_n1488)) → _gen_0':divZeroError':s'4(_n1488), rt ∈ Ω(1 + n1488)
minus'(_gen_0':divZeroError':s'4(_n2371), _gen_0':divZeroError':s'4(_n2371)) → _gen_0':divZeroError':s'4(0), rt ∈ Ω(1 + n2371)

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

The following defined symbols remain to be analysed:
plusIter'

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

Rules:
div'(x, y) → div2'(x, y, 0')
div2'(x, y, i) → if1'(le'(y, 0'), le'(y, x), x, y, plus'(i, 0'), inc'(i))
if1'(true', b, x, y, i, j) → divZeroError'
if1'(false', b, x, y, i, j) → if2'(b, x, y, i, j)
if2'(true', x, y, i, j) → div2'(minus'(x, y), y, j)
if2'(false', x, y, i, j) → i
inc'(0') → 0'
inc'(s'(i)) → s'(inc'(i))
le'(s'(x), 0') → false'
le'(0', y) → true'
le'(s'(x), s'(y)) → le'(x, y)
minus'(x, 0') → x
minus'(0', y) → 0'
minus'(s'(x), s'(y)) → minus'(x, y)
plus'(x, y) → plusIter'(x, y, 0')
plusIter'(x, y, z) → ifPlus'(le'(x, z), x, y, z)
ifPlus'(true', x, y, z) → y
ifPlus'(false', x, y, z) → plusIter'(x, s'(y), s'(z))
a'c'
a'd'

Types:
div' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
div2' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
0' :: 0':divZeroError':s'
if1' :: true':false' → true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
le' :: 0':divZeroError':s' → 0':divZeroError':s' → true':false'
plus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
inc' :: 0':divZeroError':s' → 0':divZeroError':s'
true' :: true':false'
divZeroError' :: 0':divZeroError':s'
false' :: true':false'
if2' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
minus' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
s' :: 0':divZeroError':s' → 0':divZeroError':s'
plusIter' :: 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
ifPlus' :: true':false' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s' → 0':divZeroError':s'
a' :: c':d'
c' :: c':d'
d' :: c':d'
_hole_0':divZeroError':s'1 :: 0':divZeroError':s'
_hole_true':false'2 :: true':false'
_hole_c':d'3 :: c':d'
_gen_0':divZeroError':s'4 :: Nat → 0':divZeroError':s'

Lemmas:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)
inc'(_gen_0':divZeroError':s'4(_n1488)) → _gen_0':divZeroError':s'4(_n1488), rt ∈ Ω(1 + n1488)
minus'(_gen_0':divZeroError':s'4(_n2371), _gen_0':divZeroError':s'4(_n2371)) → _gen_0':divZeroError':s'4(0), rt ∈ Ω(1 + n2371)

Generator Equations:
_gen_0':divZeroError':s'4(0) ⇔ 0'
_gen_0':divZeroError':s'4(+(x, 1)) ⇔ s'(_gen_0':divZeroError':s'4(x))

No more defined symbols left to analyse.

The lowerbound Ω(n) was proven with the following lemma:
le'(_gen_0':divZeroError':s'4(+(1, _n6)), _gen_0':divZeroError':s'4(_n6)) → false', rt ∈ Ω(1 + n6)