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.



   R
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.


   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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:
+'(x1, x2) -> +'(x1, x2)
+(x1, x2) -> +(x1, x2)
s(x1) -> s(x1)


   R
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.


   R
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:



   R
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:



   R
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(x1, x2) -> APP(x1, x2)
cons(x1, x2) -> cons(x1, x2)


   R
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.


   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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:
*'(x1, x2) -> *'(x1, x2)
s(x1) -> s(x1)
*(x1, x2) -> *(x1, x2)
+(x1, x2) -> +(x1, x2)


   R
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.


   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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(x1) -> SUM(x1)
cons(x1, x2) -> cons(x1, x2)
app(x1, x2) -> app(x1, x2)


   R
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.


   R
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:



   R
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:



   R
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:



   R
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:



   R
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:



   R
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(x1) -> PROD(x1)
cons(x1, x2) -> cons(x1, x2)
app(x1, x2) -> app(x1, x2)


   R
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