Termination Proof using AProVE

Term Rewriting System R:
[x, y, z, l, l1, l2]
+(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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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)
APP(cons(x, l1), l2) -> APP(l1, l2)
SUM(cons(x, l)) -> +'(x, sum(l))
SUM(cons(x, l)) -> SUM(l)
SUM(app(l1, l2)) -> +'(sum(l1), sum(l2))
SUM(app(l1, l2)) -> SUM(l1)
SUM(app(l1, l2)) -> SUM(l2)
PROD(cons(x, l)) -> *'(x, prod(l))
PROD(cons(x, l)) -> PROD(l)
PROD(app(l1, l2)) -> *'(prod(l1), prod(l2))
PROD(app(l1, l2)) -> PROD(l1)
PROD(app(l1, l2)) -> PROD(l2)

Furthermore, R contains five SCCs.

     ↳DPs

       →DP Problem 1

         ↳Narrowing Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Narrowing Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Nar

...

               →DP Problem 7

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Nar

...

               →DP Problem 8

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Nar

...

               →DP Problem 9

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Nar

...

               →DP Problem 10

                 ↳Forward Instantiation Transformation

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 6

             ↳Nar

...

               →DP Problem 11

                 ↳Argument Filtering and Ordering

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 w.r.t. to the AFS 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 6

             ↳Nar

...

               →DP Problem 12

                 ↳Dependency Graph

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

Dependency Pair:

APP(cons(x, l1), l2) -> APP(l1, l2)

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

APP(cons(x, l1), l2) -> APP(l1, l2)

one new Dependency Pair is created:

APP(cons(x, cons(x'', l1'')), l2'') -> APP(cons(x'', l1''), l2'')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

           →DP Problem 13

             ↳Forward Instantiation Transformation

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

Dependency Pair:

APP(cons(x, cons(x'', l1'')), l2'') -> APP(cons(x'', l1''), l2'')

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

APP(cons(x, cons(x'', l1'')), l2'') -> APP(cons(x'', l1''), l2'')

one new Dependency Pair is created:

APP(cons(x, cons(x'''', cons(x''''', l1''''))), l2'''') -> APP(cons(x'''', cons(x''''', l1'''')), l2'''')

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

           →DP Problem 13

             ↳FwdInst

...

               →DP Problem 14

                 ↳Argument Filtering and Ordering

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

Dependency Pair:

APP(cons(x, cons(x'''', cons(x''''', l1''''))), l2'''') -> APP(cons(x'''', cons(x''''', l1'''')), l2'''')

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

The following dependency pair can be strictly oriented:

APP(cons(x, cons(x'''', cons(x''''', l1''''))), l2'''') -> APP(cons(x'''', cons(x''''', l1'''')), l2'''')

There are no usable rules for innermost w.r.t. to the AFS 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:

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

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

           →DP Problem 13

             ↳FwdInst

...

               →DP Problem 15

                 ↳Dependency Graph

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Narrowing Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Narrowing Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 17

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 18

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 19

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 20

                 ↳Forward Instantiation Transformation

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 21

                 ↳Argument Filtering and Ordering

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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 w.r.t. to the AFS 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

         ↳FwdInst

       →DP Problem 3

         ↳Nar

           →DP Problem 16

             ↳Nar

...

               →DP Problem 22

                 ↳Dependency Graph

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(app(l1, l2)) -> SUM(l2)
SUM(app(l1, l2)) -> SUM(l1)
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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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)

two new Dependency Pairs are created:

SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))
SUM(app(l1, l2)) -> SUM(l1)
SUM(app(l1, l2)) -> SUM(l2)

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

SUM(app(l1, l2)) -> SUM(l1)

one new Dependency Pair is created:

SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳FwdInst

...

               →DP Problem 24

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))
SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))
SUM(app(l1, l2)) -> SUM(l2)
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

SUM(app(l1, l2)) -> SUM(l2)

four new Dependency Pairs are created:

SUM(app(l1, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(l1, cons(x'', cons(x'''', l'''')))) -> SUM(cons(x'', cons(x'''', l'''')))
SUM(app(l1, cons(x'', app(l1'''', l2'''')))) -> SUM(cons(x'', app(l1'''', l2'''')))
SUM(app(l1, app(app(l1'''', l2''''), l2''))) -> SUM(app(app(l1'''', l2''''), l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳FwdInst

...

               →DP Problem 25

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(app(l1, app(app(l1'''', l2''''), l2''))) -> SUM(app(app(l1'''', l2''''), l2''))
SUM(app(l1, cons(x'', app(l1'''', l2'''')))) -> SUM(cons(x'', app(l1'''', l2'''')))
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))
SUM(app(l1, cons(x'', cons(x'''', l'''')))) -> SUM(cons(x'', cons(x'''', l'''')))
SUM(app(l1, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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''))

two new Dependency Pairs are created:

SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))
SUM(cons(x, cons(x''', app(l1'''', l2'''')))) -> SUM(cons(x''', app(l1'''', l2'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳FwdInst

...

               →DP Problem 26

                 ↳Forward Instantiation Transformation

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(app(l1, cons(x'', app(l1'''', l2'''')))) -> SUM(cons(x'', app(l1'''', l2'''')))
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(cons(x, cons(x''', app(l1'''', l2'''')))) -> SUM(cons(x''', app(l1'''', l2'''')))
SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))
SUM(app(l1, cons(x'', cons(x'''', l'''')))) -> SUM(cons(x'', cons(x'''', l'''')))
SUM(app(l1, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))
SUM(app(l1, app(app(l1'''', l2''''), l2''))) -> SUM(app(app(l1'''', l2''''), l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

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

two new Dependency Pairs are created:

SUM(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> SUM(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
SUM(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> SUM(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳FwdInst

...

               →DP Problem 27

                 ↳Argument Filtering and Ordering

       →DP Problem 5

         ↳FwdInst

Dependency Pairs:

SUM(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> SUM(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))
SUM(cons(x, cons(x''', app(l1'''', l2'''')))) -> SUM(cons(x''', app(l1'''', l2'''')))
SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))
SUM(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> SUM(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
SUM(app(l1, app(app(l1'''', l2''''), l2''))) -> SUM(app(app(l1'''', l2''''), l2''))
SUM(app(l1, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(l1, cons(x'', app(l1'''', l2'''')))) -> SUM(cons(x'', app(l1'''', l2'''')))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

SUM(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> SUM(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))
SUM(cons(x, cons(x''', app(l1'''', l2'''')))) -> SUM(cons(x''', app(l1'''', l2'''')))
SUM(cons(x, cons(x'''', cons(x''''', l'''')))) -> SUM(cons(x'''', cons(x''''', l'''')))
SUM(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> SUM(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
SUM(app(l1, app(app(l1'''', l2''''), l2''))) -> SUM(app(app(l1'''', l2''''), l2''))
SUM(app(l1, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(app(l1'', l2''), l2)) -> SUM(app(l1'', l2''))
SUM(cons(x, app(l1'', l2''))) -> SUM(app(l1'', l2''))
SUM(app(l1, cons(x'', app(l1'''', l2'''')))) -> SUM(cons(x'', app(l1'''', l2'''')))

The following usable rules for innermost w.r.t. to the AFS can be oriented:

app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))

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

app > cons

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

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

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

           →DP Problem 23

             ↳FwdInst

...

               →DP Problem 28

                 ↳Dependency Graph

       →DP Problem 5

         ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳Forward Instantiation Transformation

Dependency Pairs:

PROD(app(l1, l2)) -> PROD(l2)
PROD(app(l1, l2)) -> PROD(l1)
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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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)

two new Dependency Pairs are created:

PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳Forward Instantiation Transformation

Dependency Pairs:

PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))
PROD(app(l1, l2)) -> PROD(l1)
PROD(app(l1, l2)) -> PROD(l2)

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

PROD(app(l1, l2)) -> PROD(l1)

one new Dependency Pair is created:

PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳FwdInst

...

               →DP Problem 30

                 ↳Forward Instantiation Transformation

Dependency Pairs:

PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))
PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))
PROD(app(l1, l2)) -> PROD(l2)
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

PROD(app(l1, l2)) -> PROD(l2)

four new Dependency Pairs are created:

PROD(app(l1, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(l1, cons(x'', cons(x'''', l'''')))) -> PROD(cons(x'', cons(x'''', l'''')))
PROD(app(l1, cons(x'', app(l1'''', l2'''')))) -> PROD(cons(x'', app(l1'''', l2'''')))
PROD(app(l1, app(app(l1'''', l2''''), l2''))) -> PROD(app(app(l1'''', l2''''), l2''))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳FwdInst

...

               →DP Problem 31

                 ↳Forward Instantiation Transformation

Dependency Pairs:

PROD(app(l1, app(app(l1'''', l2''''), l2''))) -> PROD(app(app(l1'''', l2''''), l2''))
PROD(app(l1, cons(x'', app(l1'''', l2'''')))) -> PROD(cons(x'', app(l1'''', l2'''')))
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))
PROD(app(l1, cons(x'', cons(x'''', l'''')))) -> PROD(cons(x'', cons(x'''', l'''')))
PROD(app(l1, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

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''))

two new Dependency Pairs are created:

PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))
PROD(cons(x, cons(x''', app(l1'''', l2'''')))) -> PROD(cons(x''', app(l1'''', l2'''')))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳FwdInst

...

               →DP Problem 32

                 ↳Forward Instantiation Transformation

Dependency Pairs:

PROD(app(l1, cons(x'', app(l1'''', l2'''')))) -> PROD(cons(x'', app(l1'''', l2'''')))
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(cons(x, cons(x''', app(l1'''', l2'''')))) -> PROD(cons(x''', app(l1'''', l2'''')))
PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))
PROD(app(l1, cons(x'', cons(x'''', l'''')))) -> PROD(cons(x'', cons(x'''', l'''')))
PROD(app(l1, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))
PROD(app(l1, app(app(l1'''', l2''''), l2''))) -> PROD(app(app(l1'''', l2''''), l2''))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

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

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

two new Dependency Pairs are created:

PROD(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> PROD(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
PROD(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> PROD(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))

The transformation is resulting in one new DP problem:

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳FwdInst

...

               →DP Problem 33

                 ↳Argument Filtering and Ordering

Dependency Pairs:

PROD(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> PROD(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))
PROD(cons(x, cons(x''', app(l1'''', l2'''')))) -> PROD(cons(x''', app(l1'''', l2'''')))
PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))
PROD(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> PROD(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
PROD(app(l1, app(app(l1'''', l2''''), l2''))) -> PROD(app(app(l1'''', l2''''), l2''))
PROD(app(l1, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(l1, cons(x'', app(l1'''', l2'''')))) -> PROD(cons(x'', app(l1'''', l2'''')))

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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

The following dependency pairs can be strictly oriented:

PROD(app(l1, cons(x''', cons(x'''''', app(l1'''''', l2''''''))))) -> PROD(cons(x''', cons(x'''''', app(l1'''''', l2''''''))))
PROD(cons(x, cons(x''', app(l1'''', l2'''')))) -> PROD(cons(x''', app(l1'''', l2'''')))
PROD(cons(x, cons(x'''', cons(x''''', l'''')))) -> PROD(cons(x'''', cons(x''''', l'''')))
PROD(app(l1, cons(x''', cons(x''''', cons(x'''''''', l''''''))))) -> PROD(cons(x''', cons(x''''', cons(x'''''''', l''''''))))
PROD(app(l1, app(app(l1'''', l2''''), l2''))) -> PROD(app(app(l1'''', l2''''), l2''))
PROD(app(l1, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(app(l1'', l2''), l2)) -> PROD(app(l1'', l2''))
PROD(cons(x, app(l1'', l2''))) -> PROD(app(l1'', l2''))
PROD(app(l1, cons(x'', app(l1'''', l2'''')))) -> PROD(cons(x'', app(l1'''', l2'''')))

The following usable rules for innermost w.r.t. to the AFS can be oriented:

app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))

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

{cons, app}

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

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

     ↳DPs

       →DP Problem 1

         ↳Nar

       →DP Problem 2

         ↳FwdInst

       →DP Problem 3

         ↳Nar

       →DP Problem 4

         ↳FwdInst

       →DP Problem 5

         ↳FwdInst

           →DP Problem 29

             ↳FwdInst

...

               →DP Problem 34

                 ↳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))
app(nil, l) -> l
app(cons(x, l1), l2) -> cons(x, app(l1, l2))
sum(nil) -> 0
sum(cons(x, l)) -> +(x, sum(l))
sum(app(l1, l2)) -> +(sum(l1), sum(l2))
prod(nil) -> s(0)
prod(cons(x, l)) -> *(x, prod(l))
prod(app(l1, l2)) -> *(prod(l1), prod(l2))

Strategy:

innermost

Using the Dependency Graph resulted in no new DP problems.

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