Term Rewriting System R:
[x, y, z]
c(0, x) -> x
c(x, c(y, z)) -> c(+(x, y), z)
+(0, 0) -> 0
+(0, 1) -> 1
+(0, 2) -> 2
+(0, 3) -> 3
+(0, 4) -> 4
+(0, 5) -> 5
+(0, 6) -> 6
+(0, 7) -> 7
+(0, 8) -> 8
+(0, 9) -> 9
+(1, 0) -> 1
+(1, 1) -> 2
+(1, 2) -> 3
+(1, 3) -> 4
+(1, 4) -> 5
+(1, 5) -> 6
+(1, 6) -> 7
+(1, 7) -> 8
+(1, 8) -> 9
+(1, 9) -> c(1, 0)
+(2, 0) -> 2
+(2, 1) -> 3
+(2, 2) -> 4
+(2, 3) -> 5
+(2, 4) -> 6
+(2, 5) -> 7
+(2, 6) -> 8
+(2, 7) -> 9
+(2, 8) -> c(1, 0)
+(2, 9) -> c(1, 1)
+(3, 0) -> 3
+(3, 1) -> 4
+(3, 2) -> 5
+(3, 3) -> 6
+(3, 4) -> 7
+(3, 5) -> 8
+(3, 6) -> 9
+(3, 7) -> c(1, 0)
+(3, 8) -> c(1, 1)
+(3, 9) -> c(1, 2)
+(4, 0) -> 4
+(4, 1) -> 5
+(4, 2) -> 6
+(4, 3) -> 7
+(4, 4) -> 8
+(4, 5) -> 9
+(4, 6) -> c(1, 0)
+(4, 7) -> c(1, 1)
+(4, 8) -> c(1, 2)
+(4, 9) -> c(1, 3)
+(5, 0) -> 5
+(5, 1) -> 6
+(5, 2) -> 7
+(5, 3) -> 8
+(5, 4) -> 9
+(5, 5) -> c(1, 0)
+(5, 6) -> c(1, 1)
+(5, 7) -> c(1, 2)
+(5, 8) -> c(1, 3)
+(5, 9) -> c(1, 4)
+(6, 0) -> 6
+(6, 1) -> 7
+(6, 2) -> 8
+(6, 3) -> 9
+(6, 4) -> c(1, 0)
+(6, 5) -> c(1, 1)
+(6, 6) -> c(1, 2)
+(6, 7) -> c(1, 3)
+(6, 8) -> c(1, 4)
+(6, 9) -> c(1, 5)
+(7, 0) -> 7
+(7, 1) -> 8
+(7, 2) -> 9
+(7, 3) -> c(1, 0)
+(7, 4) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(7, 6) -> c(1, 3)
+(7, 7) -> c(1, 4)
+(7, 8) -> c(1, 5)
+(7, 9) -> c(1, 6)
+(8, 0) -> 8
+(8, 1) -> 9
+(8, 2) -> c(1, 0)
+(8, 3) -> c(1, 1)
+(8, 4) -> c(1, 2)
+(8, 5) -> c(1, 3)
+(8, 6) -> c(1, 4)
+(8, 7) -> c(1, 5)
+(8, 8) -> c(1, 6)
+(8, 9) -> c(1, 7)
+(9, 0) -> 9
+(9, 1) -> c(1, 0)
+(9, 2) -> c(1, 1)
+(9, 3) -> c(1, 2)
+(9, 4) -> c(1, 3)
+(9, 5) -> c(1, 4)
+(9, 6) -> c(1, 5)
+(9, 7) -> c(1, 6)
+(9, 8) -> c(1, 7)
+(9, 9) -> c(1, 8)
+(x, c(y, z)) -> c(y, +(x, z))
+(c(x, y), z) -> c(x, +(y, z))
*(0, 0) -> 0
*(0, 1) -> 0
*(0, 2) -> 0
*(0, 3) -> 0
*(0, 4) -> 0
*(0, 5) -> 0
*(0, 6) -> 0
*(0, 7) -> 0
*(0, 8) -> 0
*(0, 9) -> 0
*(1, 0) -> 0
*(1, 1) -> 1
*(1, 2) -> 2
*(1, 3) -> 3
*(1, 4) -> 4
*(1, 5) -> 5
*(1, 6) -> 6
*(1, 7) -> 7
*(1, 8) -> 8
*(1, 9) -> 9
*(2, 0) -> 0
*(2, 1) -> 2
*(2, 2) -> 4
*(2, 3) -> 6
*(2, 4) -> 8
*(2, 5) -> c(1, 0)
*(2, 6) -> c(1, 2)
*(2, 7) -> c(1, 4)
*(2, 8) -> c(1, 6)
*(2, 9) -> c(1, 8)
*(3, 0) -> 0
*(3, 1) -> 3
*(3, 2) -> 6
*(3, 3) -> 9
*(3, 4) -> c(1, 2)
*(3, 5) -> c(1, 5)
*(3, 6) -> c(1, 8)
*(3, 7) -> c(2, 1)
*(3, 8) -> c(2, 4)
*(3, 9) -> c(2, 7)
*(4, 0) -> 0
*(4, 1) -> 4
*(4, 2) -> 8
*(4, 3) -> c(1, 2)
*(4, 4) -> c(1, 6)
*(4, 5) -> c(2, 0)
*(4, 6) -> c(2, 4)
*(4, 7) -> c(2, 8)
*(4, 8) -> c(3, 2)
*(4, 9) -> c(3, 6)
*(5, 0) -> 0
*(5, 1) -> 5
*(5, 2) -> c(1, 0)
*(5, 3) -> c(1, 5)
*(5, 4) -> c(2, 0)
*(5, 5) -> c(2, 5)
*(5, 6) -> c(3, 0)
*(5, 7) -> c(3, 5)
*(5, 8) -> c(4, 0)
*(5, 9) -> c(4, 5)
*(6, 0) -> 0
*(6, 1) -> 6
*(6, 2) -> c(1, 2)
*(6, 3) -> c(1, 8)
*(6, 4) -> c(2, 4)
*(6, 5) -> c(3, 0)
*(6, 6) -> c(3, 6)
*(6, 7) -> c(4, 2)
*(6, 8) -> c(4, 8)
*(6, 9) -> c(5, 4)
*(7, 0) -> 0
*(7, 1) -> 7
*(7, 2) -> c(1, 4)
*(7, 3) -> c(2, 1)
*(7, 4) -> c(2, 8)
*(7, 5) -> c(3, 5)
*(7, 6) -> c(4, 2)
*(7, 7) -> c(4, 9)
*(7, 8) -> c(5, 6)
*(7, 9) -> c(6, 3)
*(8, 0) -> 0
*(8, 1) -> 8
*(8, 2) -> c(1, 8)
*(8, 3) -> c(2, 4)
*(8, 4) -> c(3, 2)
*(8, 5) -> c(4, 0)
*(8, 6) -> c(4, 8)
*(8, 7) -> c(5, 6)
*(8, 8) -> c(6, 4)
*(8, 9) -> c(7, 2)
*(9, 0) -> 0
*(9, 1) -> 9
*(9, 2) -> c(1, 8)
*(9, 3) -> c(2, 7)
*(9, 4) -> c(3, 6)
*(9, 5) -> c(4, 5)
*(9, 6) -> c(5, 4)
*(9, 7) -> c(6, 3)
*(9, 8) -> c(7, 2)
*(9, 9) -> c(8, 1)
*(x, c(y, z)) -> c(*(x, y), *(x, z))
*(c(x, y), z) -> c(*(x, z), *(y, z))

Innermost Termination of R to be shown.



   R
Dependency Pair Analysis



R contains the following Dependency Pairs:

C(x, c(y, z)) -> C(+(x, y), z)
C(x, c(y, z)) -> +'(x, y)
+'(1, 9) -> C(1, 0)
+'(2, 8) -> C(1, 0)
+'(2, 9) -> C(1, 1)
+'(3, 7) -> C(1, 0)
+'(3, 8) -> C(1, 1)
+'(3, 9) -> C(1, 2)
+'(4, 6) -> C(1, 0)
+'(4, 7) -> C(1, 1)
+'(4, 8) -> C(1, 2)
+'(4, 9) -> C(1, 3)
+'(5, 5) -> C(1, 0)
+'(5, 6) -> C(1, 1)
+'(5, 7) -> C(1, 2)
+'(5, 8) -> C(1, 3)
+'(5, 9) -> C(1, 4)
+'(6, 4) -> C(1, 0)
+'(6, 5) -> C(1, 1)
+'(6, 6) -> C(1, 2)
+'(6, 7) -> C(1, 3)
+'(6, 8) -> C(1, 4)
+'(6, 9) -> C(1, 5)
+'(7, 3) -> C(1, 0)
+'(7, 4) -> C(1, 1)
+'(7, 5) -> C(1, 2)
+'(7, 6) -> C(1, 3)
+'(7, 7) -> C(1, 4)
+'(7, 8) -> C(1, 5)
+'(7, 9) -> C(1, 6)
+'(8, 2) -> C(1, 0)
+'(8, 3) -> C(1, 1)
+'(8, 4) -> C(1, 2)
+'(8, 5) -> C(1, 3)
+'(8, 6) -> C(1, 4)
+'(8, 7) -> C(1, 5)
+'(8, 8) -> C(1, 6)
+'(8, 9) -> C(1, 7)
+'(9, 1) -> C(1, 0)
+'(9, 2) -> C(1, 1)
+'(9, 3) -> C(1, 2)
+'(9, 4) -> C(1, 3)
+'(9, 5) -> C(1, 4)
+'(9, 6) -> C(1, 5)
+'(9, 7) -> C(1, 6)
+'(9, 8) -> C(1, 7)
+'(9, 9) -> C(1, 8)
+'(x, c(y, z)) -> C(y, +(x, z))
+'(x, c(y, z)) -> +'(x, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(c(x, y), z) -> +'(y, z)
*'(2, 5) -> C(1, 0)
*'(2, 6) -> C(1, 2)
*'(2, 7) -> C(1, 4)
*'(2, 8) -> C(1, 6)
*'(2, 9) -> C(1, 8)
*'(3, 4) -> C(1, 2)
*'(3, 5) -> C(1, 5)
*'(3, 6) -> C(1, 8)
*'(3, 7) -> C(2, 1)
*'(3, 8) -> C(2, 4)
*'(3, 9) -> C(2, 7)
*'(4, 3) -> C(1, 2)
*'(4, 4) -> C(1, 6)
*'(4, 5) -> C(2, 0)
*'(4, 6) -> C(2, 4)
*'(4, 7) -> C(2, 8)
*'(4, 8) -> C(3, 2)
*'(4, 9) -> C(3, 6)
*'(5, 2) -> C(1, 0)
*'(5, 3) -> C(1, 5)
*'(5, 4) -> C(2, 0)
*'(5, 5) -> C(2, 5)
*'(5, 6) -> C(3, 0)
*'(5, 7) -> C(3, 5)
*'(5, 8) -> C(4, 0)
*'(5, 9) -> C(4, 5)
*'(6, 2) -> C(1, 2)
*'(6, 3) -> C(1, 8)
*'(6, 4) -> C(2, 4)
*'(6, 5) -> C(3, 0)
*'(6, 6) -> C(3, 6)
*'(6, 7) -> C(4, 2)
*'(6, 8) -> C(4, 8)
*'(6, 9) -> C(5, 4)
*'(7, 2) -> C(1, 4)
*'(7, 3) -> C(2, 1)
*'(7, 4) -> C(2, 8)
*'(7, 5) -> C(3, 5)
*'(7, 6) -> C(4, 2)
*'(7, 7) -> C(4, 9)
*'(7, 8) -> C(5, 6)
*'(7, 9) -> C(6, 3)
*'(8, 2) -> C(1, 8)
*'(8, 3) -> C(2, 4)
*'(8, 4) -> C(3, 2)
*'(8, 5) -> C(4, 0)
*'(8, 6) -> C(4, 8)
*'(8, 7) -> C(5, 6)
*'(8, 8) -> C(6, 4)
*'(8, 9) -> C(7, 2)
*'(9, 2) -> C(1, 8)
*'(9, 3) -> C(2, 7)
*'(9, 4) -> C(3, 6)
*'(9, 5) -> C(4, 5)
*'(9, 6) -> C(5, 4)
*'(9, 7) -> C(6, 3)
*'(9, 8) -> C(7, 2)
*'(9, 9) -> C(8, 1)
*'(x, c(y, z)) -> C(*(x, y), *(x, z))
*'(x, c(y, z)) -> *'(x, y)
*'(x, c(y, z)) -> *'(x, z)
*'(c(x, y), z) -> C(*(x, z), *(y, z))
*'(c(x, y), z) -> *'(x, z)
*'(c(x, y), z) -> *'(y, z)

Furthermore, R contains two SCCs.


   R
DPs
       →DP Problem 1
Usable Rules (Innermost)
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


c(0, x) -> x
c(x, c(y, z)) -> c(+(x, y), z)
+(0, 0) -> 0
+(0, 1) -> 1
+(0, 2) -> 2
+(0, 3) -> 3
+(0, 4) -> 4
+(0, 5) -> 5
+(0, 6) -> 6
+(0, 7) -> 7
+(0, 8) -> 8
+(0, 9) -> 9
+(1, 0) -> 1
+(1, 1) -> 2
+(1, 2) -> 3
+(1, 3) -> 4
+(1, 4) -> 5
+(1, 5) -> 6
+(1, 6) -> 7
+(1, 7) -> 8
+(1, 8) -> 9
+(1, 9) -> c(1, 0)
+(2, 0) -> 2
+(2, 1) -> 3
+(2, 2) -> 4
+(2, 3) -> 5
+(2, 4) -> 6
+(2, 5) -> 7
+(2, 6) -> 8
+(2, 7) -> 9
+(2, 8) -> c(1, 0)
+(2, 9) -> c(1, 1)
+(3, 0) -> 3
+(3, 1) -> 4
+(3, 2) -> 5
+(3, 3) -> 6
+(3, 4) -> 7
+(3, 5) -> 8
+(3, 6) -> 9
+(3, 7) -> c(1, 0)
+(3, 8) -> c(1, 1)
+(3, 9) -> c(1, 2)
+(4, 0) -> 4
+(4, 1) -> 5
+(4, 2) -> 6
+(4, 3) -> 7
+(4, 4) -> 8
+(4, 5) -> 9
+(4, 6) -> c(1, 0)
+(4, 7) -> c(1, 1)
+(4, 8) -> c(1, 2)
+(4, 9) -> c(1, 3)
+(5, 0) -> 5
+(5, 1) -> 6
+(5, 2) -> 7
+(5, 3) -> 8
+(5, 4) -> 9
+(5, 5) -> c(1, 0)
+(5, 6) -> c(1, 1)
+(5, 7) -> c(1, 2)
+(5, 8) -> c(1, 3)
+(5, 9) -> c(1, 4)
+(6, 0) -> 6
+(6, 1) -> 7
+(6, 2) -> 8
+(6, 3) -> 9
+(6, 4) -> c(1, 0)
+(6, 5) -> c(1, 1)
+(6, 6) -> c(1, 2)
+(6, 7) -> c(1, 3)
+(6, 8) -> c(1, 4)
+(6, 9) -> c(1, 5)
+(7, 0) -> 7
+(7, 1) -> 8
+(7, 2) -> 9
+(7, 3) -> c(1, 0)
+(7, 4) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(7, 6) -> c(1, 3)
+(7, 7) -> c(1, 4)
+(7, 8) -> c(1, 5)
+(7, 9) -> c(1, 6)
+(8, 0) -> 8
+(8, 1) -> 9
+(8, 2) -> c(1, 0)
+(8, 3) -> c(1, 1)
+(8, 4) -> c(1, 2)
+(8, 5) -> c(1, 3)
+(8, 6) -> c(1, 4)
+(8, 7) -> c(1, 5)
+(8, 8) -> c(1, 6)
+(8, 9) -> c(1, 7)
+(9, 0) -> 9
+(9, 1) -> c(1, 0)
+(9, 2) -> c(1, 1)
+(9, 3) -> c(1, 2)
+(9, 4) -> c(1, 3)
+(9, 5) -> c(1, 4)
+(9, 6) -> c(1, 5)
+(9, 7) -> c(1, 6)
+(9, 8) -> c(1, 7)
+(9, 9) -> c(1, 8)
+(x, c(y, z)) -> c(y, +(x, z))
+(c(x, y), z) -> c(x, +(y, z))
*(0, 0) -> 0
*(0, 1) -> 0
*(0, 2) -> 0
*(0, 3) -> 0
*(0, 4) -> 0
*(0, 5) -> 0
*(0, 6) -> 0
*(0, 7) -> 0
*(0, 8) -> 0
*(0, 9) -> 0
*(1, 0) -> 0
*(1, 1) -> 1
*(1, 2) -> 2
*(1, 3) -> 3
*(1, 4) -> 4
*(1, 5) -> 5
*(1, 6) -> 6
*(1, 7) -> 7
*(1, 8) -> 8
*(1, 9) -> 9
*(2, 0) -> 0
*(2, 1) -> 2
*(2, 2) -> 4
*(2, 3) -> 6
*(2, 4) -> 8
*(2, 5) -> c(1, 0)
*(2, 6) -> c(1, 2)
*(2, 7) -> c(1, 4)
*(2, 8) -> c(1, 6)
*(2, 9) -> c(1, 8)
*(3, 0) -> 0
*(3, 1) -> 3
*(3, 2) -> 6
*(3, 3) -> 9
*(3, 4) -> c(1, 2)
*(3, 5) -> c(1, 5)
*(3, 6) -> c(1, 8)
*(3, 7) -> c(2, 1)
*(3, 8) -> c(2, 4)
*(3, 9) -> c(2, 7)
*(4, 0) -> 0
*(4, 1) -> 4
*(4, 2) -> 8
*(4, 3) -> c(1, 2)
*(4, 4) -> c(1, 6)
*(4, 5) -> c(2, 0)
*(4, 6) -> c(2, 4)
*(4, 7) -> c(2, 8)
*(4, 8) -> c(3, 2)
*(4, 9) -> c(3, 6)
*(5, 0) -> 0
*(5, 1) -> 5
*(5, 2) -> c(1, 0)
*(5, 3) -> c(1, 5)
*(5, 4) -> c(2, 0)
*(5, 5) -> c(2, 5)
*(5, 6) -> c(3, 0)
*(5, 7) -> c(3, 5)
*(5, 8) -> c(4, 0)
*(5, 9) -> c(4, 5)
*(6, 0) -> 0
*(6, 1) -> 6
*(6, 2) -> c(1, 2)
*(6, 3) -> c(1, 8)
*(6, 4) -> c(2, 4)
*(6, 5) -> c(3, 0)
*(6, 6) -> c(3, 6)
*(6, 7) -> c(4, 2)
*(6, 8) -> c(4, 8)
*(6, 9) -> c(5, 4)
*(7, 0) -> 0
*(7, 1) -> 7
*(7, 2) -> c(1, 4)
*(7, 3) -> c(2, 1)
*(7, 4) -> c(2, 8)
*(7, 5) -> c(3, 5)
*(7, 6) -> c(4, 2)
*(7, 7) -> c(4, 9)
*(7, 8) -> c(5, 6)
*(7, 9) -> c(6, 3)
*(8, 0) -> 0
*(8, 1) -> 8
*(8, 2) -> c(1, 8)
*(8, 3) -> c(2, 4)
*(8, 4) -> c(3, 2)
*(8, 5) -> c(4, 0)
*(8, 6) -> c(4, 8)
*(8, 7) -> c(5, 6)
*(8, 8) -> c(6, 4)
*(8, 9) -> c(7, 2)
*(9, 0) -> 0
*(9, 1) -> 9
*(9, 2) -> c(1, 8)
*(9, 3) -> c(2, 7)
*(9, 4) -> c(3, 6)
*(9, 5) -> c(4, 5)
*(9, 6) -> c(5, 4)
*(9, 7) -> c(6, 3)
*(9, 8) -> c(7, 2)
*(9, 9) -> c(8, 1)
*(x, c(y, z)) -> c(*(x, y), *(x, z))
*(c(x, y), z) -> c(*(x, z), *(y, z))


Strategy:

innermost




As we are in the innermost case, we can delete all 102 non-usable-rules.


   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(4, 4) -> 8
+(5, 2) -> 7
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(1, 6) -> 7
+(2, 4) -> 6
+(6, 4) -> c(1, 0)
+(9, 9) -> c(1, 8)
+(6, 5) -> c(1, 1)
+(0, 3) -> 3
+(2, 9) -> c(1, 1)
+(3, 1) -> 4
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 0) -> 9
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(0, 2) -> 2
+(2, 5) -> 7
+(7, 4) -> c(1, 1)
+(4, 6) -> c(1, 0)
+(0, 0) -> 0
+(5, 9) -> c(1, 4)
+(8, 1) -> 9
+(0, 7) -> 7
+(9, 4) -> c(1, 3)
+(1, 4) -> 5
+(3, 4) -> 7
+(7, 6) -> c(1, 3)
+(4, 5) -> 9
+(4, 9) -> c(1, 3)
+(3, 5) -> 8
+(5, 3) -> 8
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(1, 7) -> 8
+(2, 8) -> c(1, 0)
+(3, 3) -> 6
+(8, 0) -> 8
+(c(x, y), z) -> c(x, +(y, z))
+(2, 2) -> 4
+(4, 8) -> c(1, 2)
+(5, 5) -> c(1, 0)
+(0, 8) -> 8
+(3, 0) -> 3
+(9, 1) -> c(1, 0)
+(4, 2) -> 6
+(8, 2) -> c(1, 0)
+(8, 6) -> c(1, 4)
+(6, 8) -> c(1, 4)
+(9, 2) -> c(1, 1)
+(7, 0) -> 7
+(1, 8) -> 9
+(1, 1) -> 2
+(6, 0) -> 6
+(4, 3) -> 7
+(9, 6) -> c(1, 5)
+(6, 9) -> c(1, 5)
+(9, 5) -> c(1, 4)
+(9, 8) -> c(1, 7)
+(2, 0) -> 2
+(5, 0) -> 5
+(1, 0) -> 1
+(3, 7) -> c(1, 0)
+(7, 1) -> 8
+(2, 6) -> 8
+(9, 7) -> c(1, 6)
+(6, 1) -> 7
+(6, 3) -> 9
+(7, 9) -> c(1, 6)
+(5, 4) -> 9
+(1, 2) -> 3
+(9, 3) -> c(1, 2)
+(0, 6) -> 6
+(0, 9) -> 9
+(2, 1) -> 3
+(8, 7) -> c(1, 5)
+(7, 3) -> c(1, 0)
+(0, 1) -> 1
+(4, 1) -> 5
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(1, 5) -> 6
+(8, 9) -> c(1, 7)
+(7, 7) -> c(1, 4)
+(6, 2) -> 8
+(4, 7) -> c(1, 1)
+(1, 3) -> 4
+(2, 7) -> 9
+(8, 4) -> c(1, 2)
+(7, 2) -> 9
+(1, 9) -> c(1, 0)
+(5, 7) -> c(1, 2)
+(5, 1) -> 6
+(3, 6) -> 9
+(3, 2) -> 5
+(2, 3) -> 5
+(3, 9) -> c(1, 2)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(4, 4) -> 8
+(5, 2) -> 7
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(1, 6) -> 7
+(2, 4) -> 6
+(6, 4) -> c(1, 0)
+(9, 9) -> c(1, 8)
+(6, 5) -> c(1, 1)
+(0, 3) -> 3
+(2, 9) -> c(1, 1)
+(3, 1) -> 4
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 0) -> 9
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(0, 2) -> 2
+(2, 5) -> 7
+(7, 4) -> c(1, 1)
+(4, 6) -> c(1, 0)
+(0, 0) -> 0
+(5, 9) -> c(1, 4)
+(8, 1) -> 9
+(0, 7) -> 7
+(9, 4) -> c(1, 3)
+(1, 4) -> 5
+(3, 4) -> 7
+(7, 6) -> c(1, 3)
+(4, 5) -> 9
+(4, 9) -> c(1, 3)
+(3, 5) -> 8
+(5, 3) -> 8
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(1, 7) -> 8
+(2, 8) -> c(1, 0)
+(3, 3) -> 6
+(8, 0) -> 8
+(c(x, y), z) -> c(x, +(y, z))
+(2, 2) -> 4
+(4, 8) -> c(1, 2)
+(5, 5) -> c(1, 0)
+(0, 8) -> 8
+(3, 0) -> 3
+(9, 1) -> c(1, 0)
+(4, 2) -> 6
+(8, 2) -> c(1, 0)
+(8, 6) -> c(1, 4)
+(6, 8) -> c(1, 4)
+(9, 2) -> c(1, 1)
+(7, 0) -> 7
+(1, 8) -> 9
+(1, 1) -> 2
+(6, 0) -> 6
+(4, 3) -> 7
+(9, 6) -> c(1, 5)
+(6, 9) -> c(1, 5)
+(9, 5) -> c(1, 4)
+(9, 8) -> c(1, 7)
+(2, 0) -> 2
+(5, 0) -> 5
+(1, 0) -> 1
+(3, 7) -> c(1, 0)
+(7, 1) -> 8
+(2, 6) -> 8
+(9, 7) -> c(1, 6)
+(6, 1) -> 7
+(6, 3) -> 9
+(7, 9) -> c(1, 6)
+(5, 4) -> 9
+(1, 2) -> 3
+(9, 3) -> c(1, 2)
+(0, 6) -> 6
+(0, 9) -> 9
+(2, 1) -> 3
+(8, 7) -> c(1, 5)
+(7, 3) -> c(1, 0)
+(0, 1) -> 1
+(4, 1) -> 5
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(1, 5) -> 6
+(8, 9) -> c(1, 7)
+(7, 7) -> c(1, 4)
+(6, 2) -> 8
+(4, 7) -> c(1, 1)
+(1, 3) -> 4
+(2, 7) -> 9
+(8, 4) -> c(1, 2)
+(7, 2) -> 9
+(1, 9) -> c(1, 0)
+(5, 7) -> c(1, 2)
+(5, 1) -> 6
+(3, 6) -> 9
+(3, 2) -> 5
+(2, 3) -> 5
+(3, 9) -> c(1, 2)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  1  
  POL(8)=  1  
  POL(5)=  1  
  POL(2)=  1  
  POL(6)=  1  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  1  
  POL(9)=  1  
  POL(3)=  1  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  1  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(4, 4) -> 8
+(5, 2) -> 7
+(1, 6) -> 7
+(2, 4) -> 6
+(6, 4) -> c(1, 0)
+(3, 1) -> 4
+(2, 5) -> 7
+(4, 6) -> c(1, 0)
+(8, 1) -> 9
+(1, 4) -> 5
+(3, 4) -> 7
+(4, 5) -> 9
+(3, 5) -> 8
+(5, 3) -> 8
+(1, 7) -> 8
+(2, 8) -> c(1, 0)
+(3, 3) -> 6
+(2, 2) -> 4
+(5, 5) -> c(1, 0)
+(9, 1) -> c(1, 0)
+(4, 2) -> 6
+(8, 2) -> c(1, 0)
+(1, 8) -> 9
+(1, 1) -> 2
+(4, 3) -> 7
+(3, 7) -> c(1, 0)
+(7, 1) -> 8
+(2, 6) -> 8
+(6, 1) -> 7
+(6, 3) -> 9
+(5, 4) -> 9
+(1, 2) -> 3
+(2, 1) -> 3
+(7, 3) -> c(1, 0)
+(4, 1) -> 5
+(1, 5) -> 6
+(6, 2) -> 8
+(1, 3) -> 4
+(2, 7) -> 9
+(7, 2) -> 9
+(1, 9) -> c(1, 0)
+(5, 1) -> 6
+(3, 6) -> 9
+(3, 2) -> 5
+(2, 3) -> 5


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 4
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(9, 9) -> c(1, 8)
+(6, 5) -> c(1, 1)
+(0, 3) -> 3
+(2, 9) -> c(1, 1)
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 0) -> 9
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(0, 2) -> 2
+(7, 4) -> c(1, 1)
+(0, 0) -> 0
+(5, 9) -> c(1, 4)
+(0, 7) -> 7
+(9, 4) -> c(1, 3)
+(7, 6) -> c(1, 3)
+(4, 9) -> c(1, 3)
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(8, 0) -> 8
+(c(x, y), z) -> c(x, +(y, z))
+(4, 8) -> c(1, 2)
+(0, 8) -> 8
+(3, 0) -> 3
+(8, 6) -> c(1, 4)
+(6, 8) -> c(1, 4)
+(9, 2) -> c(1, 1)
+(7, 0) -> 7
+(6, 0) -> 6
+(9, 6) -> c(1, 5)
+(6, 9) -> c(1, 5)
+(9, 5) -> c(1, 4)
+(9, 8) -> c(1, 7)
+(2, 0) -> 2
+(5, 0) -> 5
+(1, 0) -> 1
+(9, 7) -> c(1, 6)
+(7, 9) -> c(1, 6)
+(9, 3) -> c(1, 2)
+(0, 6) -> 6
+(0, 9) -> 9
+(8, 7) -> c(1, 5)
+(0, 1) -> 1
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(8, 9) -> c(1, 7)
+(7, 7) -> c(1, 4)
+(4, 7) -> c(1, 1)
+(8, 4) -> c(1, 2)
+(5, 7) -> c(1, 2)
+(3, 9) -> c(1, 2)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(9, 2) -> c(1, 1)
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(9, 6) -> c(1, 5)
c(x, c(y, z)) -> c(+(x, y), z)
+(9, 9) -> c(1, 8)
+(6, 9) -> c(1, 5)
+(9, 5) -> c(1, 4)
+(9, 8) -> c(1, 7)
+(6, 5) -> c(1, 1)
+(2, 0) -> 2
+(0, 3) -> 3
+(5, 0) -> 5
+(1, 0) -> 1
+(2, 9) -> c(1, 1)
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 7) -> c(1, 6)
+(9, 0) -> 9
+(7, 9) -> c(1, 6)
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(9, 3) -> c(1, 2)
+(0, 6) -> 6
+(0, 2) -> 2
+(7, 5) -> c(1, 2)
+(7, 4) -> c(1, 1)
+(0, 9) -> 9
+(0, 0) -> 0
+(8, 7) -> c(1, 5)
+(5, 9) -> c(1, 4)
+(9, 4) -> c(1, 3)
+(0, 7) -> 7
+(0, 1) -> 1
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(7, 6) -> c(1, 3)
+(8, 9) -> c(1, 7)
+(4, 9) -> c(1, 3)
c(0, x) -> x
+(7, 7) -> c(1, 4)
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(4, 7) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(8, 5) -> c(1, 3)
+(8, 4) -> c(1, 2)
+(8, 0) -> 8
+(c(x, y), z) -> c(x, +(y, z))
+(5, 7) -> c(1, 2)
+(4, 8) -> c(1, 2)
+(0, 8) -> 8
+(3, 0) -> 3
+(8, 6) -> c(1, 4)
+(3, 9) -> c(1, 2)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(9)=  1  
  POL(3)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(9, 2) -> c(1, 1)
+(9, 6) -> c(1, 5)
+(9, 9) -> c(1, 8)
+(6, 9) -> c(1, 5)
+(9, 5) -> c(1, 4)
+(9, 8) -> c(1, 7)
+(2, 9) -> c(1, 1)
+(9, 7) -> c(1, 6)
+(7, 9) -> c(1, 6)
+(9, 3) -> c(1, 2)
+(5, 9) -> c(1, 4)
+(9, 4) -> c(1, 3)
+(8, 9) -> c(1, 7)
+(4, 9) -> c(1, 3)
+(3, 9) -> c(1, 2)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 5
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(6, 5) -> c(1, 1)
+(2, 0) -> 2
+(0, 3) -> 3
+(5, 0) -> 5
+(1, 0) -> 1
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 0) -> 9
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(0, 6) -> 6
+(0, 2) -> 2
+(7, 5) -> c(1, 2)
+(7, 4) -> c(1, 1)
+(0, 9) -> 9
+(0, 0) -> 0
+(8, 7) -> c(1, 5)
+(0, 7) -> 7
+(0, 1) -> 1
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(7, 6) -> c(1, 3)
+(7, 7) -> c(1, 4)
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(4, 7) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(8, 5) -> c(1, 3)
+(8, 4) -> c(1, 2)
+(8, 0) -> 8
+(c(x, y), z) -> c(x, +(y, z))
+(5, 7) -> c(1, 2)
+(4, 8) -> c(1, 2)
+(0, 8) -> 8
+(3, 0) -> 3
+(8, 6) -> c(1, 4)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(7, 6) -> c(1, 3)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x
+(7, 7) -> c(1, 4)
+(6, 5) -> c(1, 1)
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(4, 7) -> c(1, 1)
+(0, 5) -> 5
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(5, 7) -> c(1, 2)
+(0, 2) -> 2
+(7, 5) -> c(1, 2)
+(4, 8) -> c(1, 2)
+(7, 4) -> c(1, 1)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 7) -> c(1, 5)
+(8, 6) -> c(1, 4)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(9)=  0  
  POL(3)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  1  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(7, 8) -> c(1, 5)
+(6, 7) -> c(1, 3)
+(7, 6) -> c(1, 3)
+(7, 7) -> c(1, 4)
+(4, 7) -> c(1, 1)
+(5, 7) -> c(1, 2)
+(7, 5) -> c(1, 2)
+(7, 4) -> c(1, 1)
+(8, 7) -> c(1, 5)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 6
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(6, 5) -> c(1, 1)
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(0, 5) -> 5
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(8, 8) -> c(1, 6)
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x
+(6, 5) -> c(1, 1)
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(0, 5) -> 5
+(5, 8) -> c(1, 3)
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 8) -> c(1, 6)
+(8, 5) -> c(1, 3)
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(5, 6) -> c(1, 1)
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  1  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(9)=  0  
  POL(3)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(6, 5) -> c(1, 1)
+(5, 8) -> c(1, 3)
+(8, 5) -> c(1, 3)
+(5, 6) -> c(1, 1)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 7
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 8) -> c(1, 6)
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 3) -> c(1, 1)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(3, 8) -> c(1, 1)
+(0, 5) -> 5
+(8, 8) -> c(1, 6)
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(9)=  0  
  POL(3)=  1  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(8, 3) -> c(1, 1)
+(3, 8) -> c(1, 1)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 8
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(0, 5) -> 5
+(8, 8) -> c(1, 6)
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 7) -> 7
+(6, 8) -> c(1, 4)
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(8, 8) -> c(1, 6)
+(8, 4) -> c(1, 2)
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(4, 8) -> c(1, 2)
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
+(8, 6) -> c(1, 4)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  1  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(9)=  0  
  POL(3)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 3, 9, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(6, 8) -> c(1, 4)
+(8, 8) -> c(1, 6)
+(8, 4) -> c(1, 2)
+(4, 8) -> c(1, 2)
+(8, 6) -> c(1, 4)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 9
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 7) -> 7
+(7, 0) -> 7
+(0, 1) -> 1
+(6, 0) -> 6
+(0, 4) -> 4
+(2, 0) -> 2
+(5, 0) -> 5
+(0, 3) -> 3
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(9, 0) -> 9
+(8, 0) -> 8
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(0, 0) -> 0
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 5) -> 5
+(0, 7) -> 7
+(x, c(y, z)) -> c(y, +(x, z))
+(0, 1) -> 1
+(7, 0) -> 7
+(9, 0) -> 9
+(8, 0) -> 8
+(0, 4) -> 4
+(6, 0) -> 6
+(4, 0) -> 4
c(x, c(y, z)) -> c(+(x, y), z)
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
c(0, x) -> x
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(2, 0) -> 2
+(0, 3) -> 3
+(5, 0) -> 5
+(0, 0) -> 0
+(1, 0) -> 1
+(6, 6) -> c(1, 2)
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  1  
  POL(c(x1, x2))=  x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(3)=  0  
  POL(9)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 9, 3, +, +', 7}
No Dependency Pairs can be deleted.
The following rules can be deleted as the lhs is strictly greater than the corresponding rhs:

+(6, 6) -> c(1, 2)


The result of this processor delivers one new DP problem.



   R
DPs
       →DP Problem 1
UsableRules
           →DP Problem 3
MRR
             ...
               →DP Problem 10
Modular Removal of Rules
       →DP Problem 2
UsableRules


Dependency Pairs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)


Rules:


+(0, 5) -> 5
+(0, 7) -> 7
+(x, c(y, z)) -> c(y, +(x, z))
+(0, 1) -> 1
+(7, 0) -> 7
+(9, 0) -> 9
+(8, 0) -> 8
+(0, 4) -> 4
+(6, 0) -> 6
+(4, 0) -> 4
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(2, 0) -> 2
+(0, 3) -> 3
+(5, 0) -> 5
+(0, 0) -> 0
+(1, 0) -> 1
c(x, c(y, z)) -> c(+(x, y), z)
c(0, x) -> x


Strategy:

innermost




We have the following set of usable rules:

+(0, 5) -> 5
+(x, c(y, z)) -> c(y, +(x, z))
+(0, 7) -> 7
+(7, 0) -> 7
+(0, 1) -> 1
+(9, 0) -> 9
+(6, 0) -> 6
+(0, 4) -> 4
+(8, 0) -> 8
+(4, 0) -> 4
c(x, c(y, z)) -> c(+(x, y), z)
+(c(x, y), z) -> c(x, +(y, z))
+(0, 6) -> 6
+(0, 2) -> 2
c(0, x) -> x
+(0, 9) -> 9
+(0, 8) -> 8
+(3, 0) -> 3
+(2, 0) -> 2
+(0, 3) -> 3
+(5, 0) -> 5
+(0, 0) -> 0
+(1, 0) -> 1
To remove rules and DPs from this DP problem we used the following monotonic and CE-compatible order: Polynomial ordering.
Polynomial interpretation:
  POL(4)=  0  
  POL(8)=  0  
  POL(5)=  0  
  POL(2)=  0  
  POL(6)=  0  
  POL(c(x1, x2))=  1 + x1 + x2  
  POL(C(x1, x2))=  x1 + x2  
  POL(0)=  0  
  POL(1)=  0  
  POL(3)=  0  
  POL(9)=  0  
  POL(+(x1, x2))=  x1 + x2  
  POL(+'(x1, x2))=  x1 + x2  
  POL(7)=  0  

We have the following set D of usable symbols: {4, 8, 5, 2, 6, c, 0, C, 1, 9, 3, +, +', 7}
The following Dependency Pairs can be deleted as the lhs is strictly greater than the corresponding rhs:

+'(c(x, y), z) -> +'(y, z)
+'(c(x, y), z) -> C(x, +(y, z))
+'(x, c(y, z)) -> +'(x, z)
+'(x, c(y, z)) -> C(y, +(x, z))
C(x, c(y, z)) -> +'(x, y)

No Rules can be deleted.

After the removal, there are no SCCs in the dependency graph which results in no DP problems which have to be solved.



   R
DPs
       →DP Problem 1
UsableRules
       →DP Problem 2
Usable Rules (Innermost)


Dependency Pairs:

*'(c(x, y), z) -> *'(y, z)
*'(c(x, y), z) -> *'(x, z)
*'(x, c(y, z)) -> *'(x, z)
*'(x, c(y, z)) -> *'(x, y)


Rules:


c(0, x) -> x
c(x, c(y, z)) -> c(+(x, y), z)
+(0, 0) -> 0
+(0, 1) -> 1
+(0, 2) -> 2
+(0, 3) -> 3
+(0, 4) -> 4
+(0, 5) -> 5
+(0, 6) -> 6
+(0, 7) -> 7
+(0, 8) -> 8
+(0, 9) -> 9
+(1, 0) -> 1
+(1, 1) -> 2
+(1, 2) -> 3
+(1, 3) -> 4
+(1, 4) -> 5
+(1, 5) -> 6
+(1, 6) -> 7
+(1, 7) -> 8
+(1, 8) -> 9
+(1, 9) -> c(1, 0)
+(2, 0) -> 2
+(2, 1) -> 3
+(2, 2) -> 4
+(2, 3) -> 5
+(2, 4) -> 6
+(2, 5) -> 7
+(2, 6) -> 8
+(2, 7) -> 9
+(2, 8) -> c(1, 0)
+(2, 9) -> c(1, 1)
+(3, 0) -> 3
+(3, 1) -> 4
+(3, 2) -> 5
+(3, 3) -> 6
+(3, 4) -> 7
+(3, 5) -> 8
+(3, 6) -> 9
+(3, 7) -> c(1, 0)
+(3, 8) -> c(1, 1)
+(3, 9) -> c(1, 2)
+(4, 0) -> 4
+(4, 1) -> 5
+(4, 2) -> 6
+(4, 3) -> 7
+(4, 4) -> 8
+(4, 5) -> 9
+(4, 6) -> c(1, 0)
+(4, 7) -> c(1, 1)
+(4, 8) -> c(1, 2)
+(4, 9) -> c(1, 3)
+(5, 0) -> 5
+(5, 1) -> 6
+(5, 2) -> 7
+(5, 3) -> 8
+(5, 4) -> 9
+(5, 5) -> c(1, 0)
+(5, 6) -> c(1, 1)
+(5, 7) -> c(1, 2)
+(5, 8) -> c(1, 3)
+(5, 9) -> c(1, 4)
+(6, 0) -> 6
+(6, 1) -> 7
+(6, 2) -> 8
+(6, 3) -> 9
+(6, 4) -> c(1, 0)
+(6, 5) -> c(1, 1)
+(6, 6) -> c(1, 2)
+(6, 7) -> c(1, 3)
+(6, 8) -> c(1, 4)
+(6, 9) -> c(1, 5)
+(7, 0) -> 7
+(7, 1) -> 8
+(7, 2) -> 9
+(7, 3) -> c(1, 0)
+(7, 4) -> c(1, 1)
+(7, 5) -> c(1, 2)
+(7, 6) -> c(1, 3)
+(7, 7) -> c(1, 4)
+(7, 8) -> c(1, 5)
+(7, 9) -> c(1, 6)
+(8, 0) -> 8
+(8, 1) -> 9
+(8, 2) -> c(1, 0)
+(8, 3) -> c(1, 1)
+(8, 4) -> c(1, 2)
+(8, 5) -> c(1, 3)
+(8, 6) -> c(1, 4)
+(8, 7) -> c(1, 5)
+(8, 8) -> c(1, 6)
+(8, 9) -> c(1, 7)
+(9, 0) -> 9
+(9, 1) -> c(1, 0)
+(9, 2) -> c(1, 1)
+(9, 3) -> c(1, 2)
+(9, 4) -> c(1, 3)
+(9, 5) -> c(1, 4)
+(9, 6) -> c(1, 5)
+(9, 7) -> c(1, 6)
+(9, 8) -> c(1, 7)
+(9, 9) -> c(1, 8)
+(x, c(y, z)) -> c(y, +(x, z))
+(c(x, y), z) -> c(x, +(y, z))
*(0, 0) -> 0
*(0, 1) -> 0
*(0, 2) -> 0
*(0, 3) -> 0
*(0, 4) -> 0
*(0, 5) -> 0
*(0, 6) -> 0
*(0, 7) -> 0
*(0, 8) -> 0
*(0, 9) -> 0
*(1, 0) -> 0
*(1, 1) -> 1
*(1, 2) -> 2
*(1, 3) -> 3
*(1, 4) -> 4
*(1, 5) -> 5
*(1, 6) -> 6
*(1, 7) -> 7
*(1, 8) -> 8
*(1, 9) -> 9
*(2, 0) -> 0
*(2, 1) -> 2
*(2, 2) -> 4
*(2, 3) -> 6
*(2, 4) -> 8
*(2, 5) -> c(1, 0)
*(2, 6) -> c(1, 2)
*(2, 7) -> c(1, 4)
*(2, 8) -> c(1, 6)
*(2, 9) -> c(1, 8)
*(3, 0) -> 0
*(3, 1) -> 3
*(3, 2) -> 6
*(3, 3) -> 9
*(3, 4) -> c(1, 2)
*(3, 5) -> c(1, 5)
*(3, 6) -> c(1, 8)
*(3, 7) -> c(2, 1)
*(3, 8) -> c(2, 4)
*(3, 9) -> c(2, 7)
*(4, 0) -> 0
*(4, 1) -> 4
*(4, 2) -> 8
*(4, 3) -> c(1, 2)
*(4, 4) -> c(1, 6)
*(4, 5) -> c(2, 0)
*(4, 6) -> c(2, 4)
*(4, 7) -> c(2, 8)
*(4, 8) -> c(3, 2)
*(4, 9) -> c(3, 6)
*(5, 0) -> 0
*(5, 1) -> 5
*(5, 2) -> c(1, 0)
*(5, 3) -> c(1, 5)
*(5, 4) -> c(2, 0)
*(5, 5) -> c(2, 5)
*(5, 6) -> c(3, 0)
*(5, 7) -> c(3, 5)
*(5, 8) -> c(4, 0)
*(5, 9) -> c(4, 5)
*(6, 0) -> 0
*(6, 1) -> 6
*(6, 2) -> c(1, 2)
*(6, 3) -> c(1, 8)
*(6, 4) -> c(2, 4)
*(6, 5) -> c(3, 0)
*(6, 6) -> c(3, 6)
*(6, 7) -> c(4, 2)
*(6, 8) -> c(4, 8)
*(6, 9) -> c(5, 4)
*(7, 0) -> 0
*(7, 1) -> 7
*(7, 2) -> c(1, 4)
*(7, 3) -> c(2, 1)
*(7, 4) -> c(2, 8)
*(7, 5) -> c(3, 5)
*(7, 6) -> c(4, 2)
*(7, 7) -> c(4, 9)
*(7, 8) -> c(5, 6)
*(7, 9) -> c(6, 3)
*(8, 0) -> 0
*(8, 1) -> 8
*(8, 2) -> c(1, 8)
*(8, 3) -> c(2, 4)
*(8, 4) -> c(3, 2)
*(8, 5) -> c(4, 0)
*(8, 6) -> c(4, 8)
*(8, 7) -> c(5, 6)
*(8, 8) -> c(6, 4)
*(8, 9) -> c(7, 2)
*(9, 0) -> 0
*(9, 1) -> 9
*(9, 2) -> c(1, 8)
*(9, 3) -> c(2, 7)
*(9, 4) -> c(3, 6)
*(9, 5) -> c(4, 5)
*(9, 6) -> c(5, 4)
*(9, 7) -> c(6, 3)
*(9, 8) -> c(7, 2)
*(9, 9) -> c(8, 1)
*(x, c(y, z)) -> c(*(x, y), *(x, z))
*(c(x, y), z) -> c(*(x, z), *(y, z))


Strategy:

innermost




As we are in the innermost case, we can delete all 206 non-usable-rules.


   R
DPs
       →DP Problem 1
UsableRules
       →DP Problem 2
UsableRules
           →DP Problem 11
Size-Change Principle


Dependency Pairs:

*'(c(x, y), z) -> *'(y, z)
*'(c(x, y), z) -> *'(x, z)
*'(x, c(y, z)) -> *'(x, z)
*'(x, c(y, z)) -> *'(x, y)


Rule:

none


Strategy:

innermost




We number the DPs as follows:
  1. *'(c(x, y), z) -> *'(y, z)
  2. *'(c(x, y), z) -> *'(x, z)
  3. *'(x, c(y, z)) -> *'(x, z)
  4. *'(x, c(y, z)) -> *'(x, y)
and get the following Size-Change Graph(s):
{1} , {1}
1>1
2=2
{2} , {2}
1>1
2=2
{3} , {3}
1=1
2>2
{4} , {4}
1=1
2>2

which lead(s) to this/these maximal multigraph(s):
{2} , {2}
1>1
2=2
{4} , {4}
1=1
2>2
{1} , {3}
1>1
2>2
{3} , {2}
1>1
2>2
{2} , {3}
1>1
2>2
{3} , {1}
1>1
2>2
{4} , {1}
1>1
2>2
{1} , {4}
1>1
2>2
{2} , {4}
1>1
2>2
{4} , {2}
1>1
2>2
{3} , {4}
1>1
2>2
{4} , {4}
1>1
2>2
{1} , {2}
1>1
2>2
{2} , {2}
1>1
2>2

DP: empty set
Oriented Rules: none

We used the order Homeomorphic Embedding Order with Non-Strict Precedence.
trivial

with Argument Filtering System:
c(x1, x2) -> c(x1, x2)

We obtain no new DP problems.

Innermost Termination of R successfully shown.
Duration:
0:38 minutes