Termination Proof using AProVE

Term Rewriting System R:
[x, y, z, l]
+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Innermost Termination of R to be shown.

     ↳Dependency Pair Analysis

R contains the following Dependency Pairs:

+'(s(x), s(y)) -> +'(x, y)
+'(+(x, y), z) -> +'(x, +(y, z))
+'(+(x, y), z) -> +'(y, z)
*'(s(x), s(y)) -> +'(*(x, y), +(x, y))
*'(s(x), s(y)) -> *'(x, y)
*'(s(x), s(y)) -> +'(x, y)
*'(*(x, y), z) -> *'(x, *(y, z))
*'(*(x, y), z) -> *'(y, z)
SUM(cons(x, l)) -> +'(x, sum(l))
SUM(cons(x, l)) -> SUM(l)
PROD(cons(x, l)) -> *'(x, prod(l))
PROD(cons(x, l)) -> PROD(l)

Furthermore, R contains four SCCs.

     ↳DPs

       →DP Problem 1

         ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, y), z) -> +'(y, z)
+'(+(x, y), z) -> +'(x, +(y, z))
+'(s(x), s(y)) -> +'(x, y)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

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

three new Dependency Pairs are created:

+'(+(x, y'), 0) -> +'(x, y')
+'(+(x, s(x'')), s(y'')) -> +'(x, s(s(+(x'', y''))))
+'(+(x, +(x'', y'')), z'') -> +'(x, +(x'', +(y'', z'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Narrowing Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, +(x'', y'')), z'') -> +'(x, +(x'', +(y'', z'')))
+'(s(x), s(y)) -> +'(x, y)
+'(+(x, y), z) -> +'(y, z)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

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

three new Dependency Pairs are created:

+'(+(x, +(x'', y''')), 0) -> +'(x, +(x'', y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 6

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(+(x, y), z) -> +'(y, z)
+'(s(x), s(y)) -> +'(x, y)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

+'(s(x), s(y)) -> +'(x, y)

four new Dependency Pairs are created:

+'(s(s(x'')), s(s(y''))) -> +'(s(x''), s(y''))
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 7

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(+(x, y), z) -> +'(y, z)
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(s(s(x'')), s(s(y''))) -> +'(s(x''), s(y''))
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

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

seven new Dependency Pairs are created:

+'(+(x, +(x'', y'')), z'') -> +'(+(x'', y''), z'')
+'(+(x, +(x'', +(x''''0, s(x'''''')))), s(y''')) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', +(x''''0, +(x'''''', y''')))), z') -> +'(+(x'', +(x''''0, +(x'''''', y'''))), z')
+'(+(x, s(s(x''''))), s(s(y''''))) -> +'(s(s(x'''')), s(s(y'''')))
+'(+(x, s(+(x'''', y''''))), s(y0'')) -> +'(s(+(x'''', y'''')), s(y0''))
+'(+(x, s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(y'''''))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(+(x, s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(y''')) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 8

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(y''')) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(+(x, s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(y'''''))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(+(x, s(+(x'''', y''''))), s(y0'')) -> +'(s(+(x'''', y'''')), s(y0''))
+'(+(x, s(s(x''''))), s(s(y''''))) -> +'(s(s(x'''')), s(s(y'''')))
+'(+(x, +(x'', +(x''''0, +(x'''''', y''')))), z') -> +'(+(x'', +(x''''0, +(x'''''', y'''))), z')
+'(+(x, +(x'', +(x''''0, s(x'''''')))), s(y''')) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', y'')), z'') -> +'(+(x'', y''), z'')
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(s(s(x'')), s(s(y''))) -> +'(s(x''), s(y''))
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))
+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

+'(s(s(x'')), s(s(y''))) -> +'(s(x''), s(y''))

four new Dependency Pairs are created:

+'(s(s(s(x''''))), s(s(s(y'''')))) -> +'(s(s(x'''')), s(s(y'''')))
+'(s(s(+(x'''', y''''))), s(s(y''0))) -> +'(s(+(x'''', y'''')), s(y''0))
+'(s(s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(s(s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(s(y'''))) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 9

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(y'''''))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(+(x, s(+(x'''', y''''))), s(y0'')) -> +'(s(+(x'''', y'''')), s(y0''))
+'(+(x, s(s(x''''))), s(s(y''''))) -> +'(s(s(x'''')), s(s(y'''')))
+'(s(s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(s(y'''))) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(s(s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(s(s(+(x'''', y''''))), s(s(y''0))) -> +'(s(+(x'''', y'''')), s(y''0))
+'(s(s(s(x''''))), s(s(s(y'''')))) -> +'(s(s(x'''')), s(s(y'''')))
+'(+(x, +(x'', +(x''''0, +(x'''''', y''')))), z') -> +'(+(x'', +(x''''0, +(x'''''', y'''))), z')
+'(+(x, +(x'', +(x''''0, s(x'''''')))), s(y''')) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))
+'(+(x, +(x'', y'')), z'') -> +'(+(x'', y''), z'')
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(+(x, s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(y''')) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

+'(+(x, s(s(x''''))), s(s(y''''))) -> +'(s(s(x'''')), s(s(y'''')))

four new Dependency Pairs are created:

+'(+(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> +'(s(s(s(x''''''))), s(s(s(y''''''))))
+'(+(x, s(s(+(x'''''', y'''''')))), s(s(y''''0))) -> +'(s(s(+(x'''''', y''''''))), s(s(y''''0)))
+'(+(x, s(s(+(x'''''', +(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> +'(s(s(+(x'''''', +(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
+'(+(x, s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y''''''')))))), s(s(y'''''))) -> +'(s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y'''''''))))), s(s(y''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 10

                 ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

+'(+(x, s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y''''''')))))), s(s(y'''''))) -> +'(s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y'''''''))))), s(s(y''''')))
+'(+(x, s(s(+(x'''''', +(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> +'(s(s(+(x'''''', +(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
+'(+(x, s(s(+(x'''''', y'''''')))), s(s(y''''0))) -> +'(s(s(+(x'''''', y''''''))), s(s(y''''0)))
+'(+(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> +'(s(s(s(x''''''))), s(s(s(y''''''))))
+'(+(x, s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(y''')) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(+(x, s(+(x'''', y''''))), s(y0'')) -> +'(s(+(x'''', y'''')), s(y0''))
+'(s(s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(s(y'''))) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(s(s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(s(s(+(x'''', y''''))), s(s(y''0))) -> +'(s(+(x'''', y'''')), s(y''0))
+'(s(s(s(x''''))), s(s(s(y'''')))) -> +'(s(s(x'''')), s(s(y'''')))
+'(+(x, +(x'', +(x''''0, +(x'''''', y''')))), z') -> +'(+(x'', +(x''''0, +(x'''''', y'''))), z')
+'(+(x, +(x'', +(x''''0, s(x'''''')))), s(y''')) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))
+'(+(x, +(x'', y'')), z'') -> +'(+(x'', y''), z'')
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(+(x, s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(y'''''))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

+'(+(x, s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y''''''')))))), s(s(y'''''))) -> +'(s(s(+(x'''''', +(x''''0'''', +(x'''''''''', y'''''''))))), s(s(y''''')))
+'(+(x, s(s(+(x'''''', +(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> +'(s(s(+(x'''''', +(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
+'(+(x, s(s(+(x'''''', y'''''')))), s(s(y''''0))) -> +'(s(s(+(x'''''', y''''''))), s(s(y''''0)))
+'(+(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> +'(s(s(s(x''''''))), s(s(s(y''''''))))
+'(+(x, s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(y''')) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(+(x, s(+(x'''', y''''))), s(y0'')) -> +'(s(+(x'''', y'''')), s(y0''))
+'(s(s(+(x'''', +(x''''0'', +(x'''''''', y'''''))))), s(s(y'''))) -> +'(s(+(x'''', +(x''''0'', +(x'''''''', y''''')))), s(y'''))
+'(s(s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))
+'(s(s(+(x'''', y''''))), s(s(y''0))) -> +'(s(+(x'''', y'''')), s(y''0))
+'(s(s(s(x''''))), s(s(s(y'''')))) -> +'(s(s(x'''')), s(s(y'''')))
+'(+(x, +(x'', +(x''''0, +(x'''''', y''')))), z') -> +'(+(x'', +(x''''0, +(x'''''', y'''))), z')
+'(+(x, +(x'', +(x''''0, s(x'''''')))), s(y''')) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(s(+(x'', +(x''''0, +(x'''''', y''')))), s(y')) -> +'(+(x'', +(x''''0, +(x'''''', y'''))), y')
+'(+(x, +(x'', +(x''', y'))), z''') -> +'(x, +(x'', +(x''', +(y', z'''))))
+'(+(x, +(x'', y'')), z'') -> +'(+(x'', y''), z'')
+'(s(+(x'', +(x''''0, s(x'''''')))), s(s(y'''))) -> +'(+(x'', +(x''''0, s(x''''''))), s(y'''))
+'(+(x, +(x'', s(x'''))), s(y')) -> +'(x, +(x'', s(s(+(x''', y')))))
+'(s(+(x'', y'')), s(y0)) -> +'(+(x'', y''), y0)
+'(+(x, s(+(x'''', +(x''''0'', s(x''''''''))))), s(s(y'''''))) -> +'(s(+(x'''', +(x''''0'', s(x'''''''')))), s(s(y''''')))

The following usable rules for innermost can be oriented:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))

Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:

{+', +} > s

resulting in one new DP problem.
Used Argument Filtering System:

+'(x₁, x₂) -> +'(x₁, x₂)
+(x₁, x₂) -> +(x₁, x₂)
s(x₁) -> s(x₁)

     ↳DPs

       →DP Problem 1

         ↳Nar

           →DP Problem 5

             ↳Nar

...

               →DP Problem 11

                 ↳Dependency Graph

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Narrowing Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

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

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

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

three new Dependency Pairs are created:

*'(*(x, y'), 0) -> *'(x, 0)
*'(*(x, s(x'')), s(y'')) -> *'(x, s(+(*(x'', y''), +(x'', y''))))
*'(*(x, *(x'', y'')), z'') -> *'(x, *(x'', *(y'', z'')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Narrowing Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

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

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Narrowing SCC transformation can be performed.
As a result of transforming the rule

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

three new Dependency Pairs are created:

*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 13

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(*(x, y), z) -> *'(y, z)
*'(s(x), s(y)) -> *'(x, y)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

*'(s(x), s(y)) -> *'(x, y)

five new Dependency Pairs are created:

*'(s(s(x'')), s(s(y''))) -> *'(s(x''), s(y''))
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 14

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(*(x, y), z) -> *'(y, z)
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(s(s(x'')), s(s(y''))) -> *'(s(x''), s(y''))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

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

nine new Dependency Pairs are created:

*'(*(x, *(x'', y'')), z'') -> *'(*(x'', y''), z'')
*'(*(x, *(x'', *(x'''', y'''''))), 0) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', *(x''''0, s(x'''''')))), s(y''')) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''''0, *(x'''''', y''')))), z') -> *'(*(x'', *(x''''0, *(x'''''', y'''))), z')
*'(*(x, s(s(x''''))), s(s(y''''))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, s(*(x'''', y''''))), s(y0'')) -> *'(s(*(x'''', y'''')), s(y0''))
*'(*(x, s(*(x'''', *(x'''''', y''''''')))), s(0)) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(*(x, s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(y'''''))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(*(x, s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(y''')) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 15

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

*'(*(x, s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(y''')) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(*(x, s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(y'''''))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(*(x, s(*(x'''', *(x'''''', y''''''')))), s(0)) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(*(x, s(*(x'''', y''''))), s(y0'')) -> *'(s(*(x'''', y'''')), s(y0''))
*'(*(x, s(s(x''''))), s(s(y''''))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, *(x'', *(x''''0, s(x'''''')))), s(y''')) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''''0, *(x'''''', y''')))), z') -> *'(*(x'', *(x''''0, *(x'''''', y'''))), z')
*'(*(x, *(x'', *(x'''', y'''''))), 0) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y'')), z'') -> *'(*(x'', y''), z'')
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(s(s(x'')), s(s(y''))) -> *'(s(x''), s(y''))
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

*'(s(s(x'')), s(s(y''))) -> *'(s(x''), s(y''))

five new Dependency Pairs are created:

*'(s(s(s(x''''))), s(s(s(y'''')))) -> *'(s(s(x'''')), s(s(y'''')))
*'(s(s(*(x'''', y''''))), s(s(y''0))) -> *'(s(*(x'''', y'''')), s(y''0))
*'(s(s(*(x'''', *(x'''''', y''''''')))), s(s(0))) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(s(s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(s(s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(s(y'''))) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 16

                 ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

*'(*(x, s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(y'''''))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(*(x, s(*(x'''', *(x'''''', y''''''')))), s(0)) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(*(x, s(*(x'''', y''''))), s(y0'')) -> *'(s(*(x'''', y'''')), s(y0''))
*'(s(s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(s(y'''))) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(s(s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(s(s(*(x'''', *(x'''''', y''''''')))), s(s(0))) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(s(s(*(x'''', y''''))), s(s(y''0))) -> *'(s(*(x'''', y'''')), s(y''0))
*'(s(s(s(x''''))), s(s(s(y'''')))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, s(s(x''''))), s(s(y''''))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, *(x'', *(x''''0, s(x'''''')))), s(y''')) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''''0, *(x'''''', y''')))), z') -> *'(*(x'', *(x''''0, *(x'''''', y'''))), z')
*'(*(x, *(x'', *(x'''', y'''''))), 0) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y'')), z'') -> *'(*(x'', y''), z'')
*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(*(x, s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(y''')) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

*'(*(x, s(s(x''''))), s(s(y''''))) -> *'(s(s(x'''')), s(s(y'''')))

five new Dependency Pairs are created:

*'(*(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> *'(s(s(s(x''''''))), s(s(s(y''''''))))
*'(*(x, s(s(*(x'''''', y'''''')))), s(s(y''''0))) -> *'(s(s(*(x'''''', y''''''))), s(s(y''''0)))
*'(*(x, s(s(*(x'''''', *(x'''''''', y'''''''''))))), s(s(0))) -> *'(s(s(*(x'''''', *(x'''''''', y''''''''')))), s(s(0)))
*'(*(x, s(s(*(x'''''', *(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> *'(s(s(*(x'''''', *(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
*'(*(x, s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y''''''')))))), s(s(y'''''))) -> *'(s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y'''''''))))), s(s(y''''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 17

                 ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pairs:

*'(*(x, s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y''''''')))))), s(s(y'''''))) -> *'(s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y'''''''))))), s(s(y''''')))
*'(*(x, s(s(*(x'''''', *(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> *'(s(s(*(x'''''', *(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
*'(*(x, s(s(*(x'''''', *(x'''''''', y'''''''''))))), s(s(0))) -> *'(s(s(*(x'''''', *(x'''''''', y''''''''')))), s(s(0)))
*'(*(x, s(s(*(x'''''', y'''''')))), s(s(y''''0))) -> *'(s(s(*(x'''''', y''''''))), s(s(y''''0)))
*'(s(s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(s(y'''))) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(s(s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(s(s(*(x'''', *(x'''''', y''''''')))), s(s(0))) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(s(s(*(x'''', y''''))), s(s(y''0))) -> *'(s(*(x'''', y'''')), s(y''0))
*'(s(s(s(x''''))), s(s(s(y'''')))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> *'(s(s(s(x''''''))), s(s(s(y''''''))))
*'(*(x, s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(y''')) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(*(x, s(*(x'''', *(x'''''', y''''''')))), s(0)) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(*(x, s(*(x'''', y''''))), s(y0'')) -> *'(s(*(x'''', y'''')), s(y0''))
*'(*(x, *(x'', *(x''''0, s(x'''''')))), s(y''')) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''''0, *(x'''''', y''')))), z') -> *'(*(x'', *(x''''0, *(x'''''', y'''))), z')
*'(*(x, *(x'', *(x'''', y'''''))), 0) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y'')), z'') -> *'(*(x'', y''), z'')
*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(*(x, s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(y'''''))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

*'(*(x, s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y''''''')))))), s(s(y'''''))) -> *'(s(s(*(x'''''', *(x''''0'''', *(x'''''''''', y'''''''))))), s(s(y''''')))
*'(*(x, s(s(*(x'''''', *(x''''0'''', s(x'''''''''')))))), s(s(s(y''''''')))) -> *'(s(s(*(x'''''', *(x''''0'''', s(x''''''''''))))), s(s(s(y'''''''))))
*'(*(x, s(s(*(x'''''', *(x'''''''', y'''''''''))))), s(s(0))) -> *'(s(s(*(x'''''', *(x'''''''', y''''''''')))), s(s(0)))
*'(*(x, s(s(*(x'''''', y'''''')))), s(s(y''''0))) -> *'(s(s(*(x'''''', y''''''))), s(s(y''''0)))
*'(s(s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(s(y'''))) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(s(s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(s(y''''')))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))
*'(s(s(*(x'''', *(x'''''', y''''''')))), s(s(0))) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(s(s(*(x'''', y''''))), s(s(y''0))) -> *'(s(*(x'''', y'''')), s(y''0))
*'(s(s(s(x''''))), s(s(s(y'''')))) -> *'(s(s(x'''')), s(s(y'''')))
*'(*(x, s(s(s(x'''''')))), s(s(s(y'''''')))) -> *'(s(s(s(x''''''))), s(s(s(y''''''))))
*'(*(x, s(*(x'''', *(x''''0'', *(x'''''''', y'''''))))), s(y''')) -> *'(s(*(x'''', *(x''''0'', *(x'''''''', y''''')))), s(y'''))
*'(*(x, s(*(x'''', *(x'''''', y''''''')))), s(0)) -> *'(s(*(x'''', *(x'''''', y'''''''))), s(0))
*'(*(x, s(*(x'''', y''''))), s(y0'')) -> *'(s(*(x'''', y'''')), s(y0''))
*'(*(x, *(x'', *(x''''0, s(x'''''')))), s(y''')) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''''0, *(x'''''', y''')))), z') -> *'(*(x'', *(x''''0, *(x'''''', y'''))), z')
*'(*(x, *(x'', *(x'''', y'''''))), 0) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y'')), z'') -> *'(*(x'', y''), z'')
*'(s(*(x'', *(x''''0, *(x'''''', y''')))), s(y')) -> *'(*(x'', *(x''''0, *(x'''''', y'''))), y')
*'(*(x, *(x'', s(x'''))), s(y')) -> *'(x, *(x'', s(+(*(x''', y'), +(x''', y')))))
*'(s(*(x'', *(x''''0, s(x'''''')))), s(s(y'''))) -> *'(*(x'', *(x''''0, s(x''''''))), s(y'''))
*'(*(x, *(x'', *(x''', y'))), z''') -> *'(x, *(x'', *(x''', *(y', z'''))))
*'(s(*(x'', *(x'''', y'''''))), s(0)) -> *'(*(x'', *(x'''', y''''')), 0)
*'(*(x, *(x'', y''')), 0) -> *'(x, *(x'', 0))
*'(s(*(x'', y'')), s(y0)) -> *'(*(x'', y''), y0)
*'(*(x, s(*(x'''', *(x''''0'', s(x''''''''))))), s(s(y'''''))) -> *'(s(*(x'''', *(x''''0'', s(x'''''''')))), s(s(y''''')))

The following usable rules for innermost can be oriented:

*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))

Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:

*' > * > + > s

resulting in one new DP problem.
Used Argument Filtering System:

*'(x₁, x₂) -> *'(x₁, x₂)
s(x₁) -> s(x₁)
*(x₁, x₂) -> *(x₁, x₂)
+(x₁, x₂) -> +(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

           →DP Problem 12

             ↳Nar

...

               →DP Problem 18

                 ↳Dependency Graph

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

SUM(cons(x, l)) -> SUM(l)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

SUM(cons(x, l)) -> SUM(l)

one new Dependency Pair is created:

SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

           →DP Problem 19

             ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))

one new Dependency Pair is created:

SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

           →DP Problem 19

             ↳FwdInst

...

               →DP Problem 20

                 ↳Argument Filtering and Ordering

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

The following dependency pair can be strictly oriented:

SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))

There are no usable rules for innermost that need to be oriented.
Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:

trivial

resulting in one new DP problem.
Used Argument Filtering System:

SUM(x₁) -> SUM(x₁)
cons(x₁, x₂) -> cons(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

           →DP Problem 19

             ↳FwdInst

...

               →DP Problem 21

                 ↳Dependency Graph

       →DP Problem 4

         ↳FwdInst

Dependency Pair:

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳Forward Instantiation Transformation

Dependency Pair:

PROD(cons(x, l)) -> PROD(l)

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

PROD(cons(x, l)) -> PROD(l)

one new Dependency Pair is created:

PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

           →DP Problem 22

             ↳Forward Instantiation Transformation

Dependency Pair:

PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

On this DP problem, a Forward Instantiation SCC transformation can be performed.
As a result of transforming the rule

PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))

one new Dependency Pair is created:

PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

           →DP Problem 22

             ↳FwdInst

...

               →DP Problem 23

                 ↳Argument Filtering and Ordering

Dependency Pair:

PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

The following dependency pair can be strictly oriented:

PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))

There are no usable rules for innermost that need to be oriented.
Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:

trivial

resulting in one new DP problem.
Used Argument Filtering System:

PROD(x₁) -> PROD(x₁)
cons(x₁, x₂) -> cons(x₁, x₂)

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Nar

       →DP Problem 3

         ↳FwdInst

       →DP Problem 4

         ↳FwdInst

           →DP Problem 22

             ↳FwdInst

...

               →DP Problem 24

                 ↳Dependency Graph

Dependency Pair:

Rules:

+(x, 0) -> x
+(0, x) -> x
+(s(x), s(y)) -> s(s(+(x, y)))
+(+(x, y), z) -> +(x, +(y, z))
*(x, 0) -> 0
*(0, x) -> 0
*(s(x), s(y)) -> s(+(*(x, y), +(x, y)))
*(*(x, y), z) -> *(x, *(y, z))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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