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

Innermost Termination of R to be shown.



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

Furthermore, R contains four SCCs.


   R
DPs
       →DP Problem 1
Narrowing Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(+(x, y), z) -> +'(x, +(y, z))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Narrowing Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(+(x, +(x'', y'')), z'') -> +'(x, +(x'', +(y'', z'')))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 6
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(s(x), s(y)) -> +'(x, y)
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 7
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(+(x, y), z) -> +'(y, z)
seven new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 8
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(s(s(x'')), s(s(y''))) -> +'(s(x''), s(y''))
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 9
Forward Instantiation Transformation
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

+'(+(x, s(s(x''''))), s(s(y''''))) -> +'(s(s(x'''')), s(s(y'''')))
four new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 10
Argument Filtering and Ordering
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


The following usable rules for innermost can be oriented:

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


Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:
{+', +} > s

resulting in one new DP problem.
Used Argument Filtering System:
+'(x1, x2) -> +'(x1, x2)
+(x1, x2) -> +(x1, x2)
s(x1) -> s(x1)


   R
DPs
       →DP Problem 1
Nar
           →DP Problem 5
Nar
             ...
               →DP Problem 11
Dependency Graph
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pair:


Rules:


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


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Narrowing Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(*(x, y), z) -> *'(x, *(y, z))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Narrowing Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(*(x, *(x'', y'')), z'') -> *'(x, *(x'', *(y'', z'')))
three new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 13
Forward Instantiation Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(s(x), s(y)) -> *'(x, y)
five new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 14
Forward Instantiation Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(*(x, y), z) -> *'(y, z)
nine new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 15
Forward Instantiation Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(s(s(x'')), s(s(y''))) -> *'(s(x''), s(y''))
five new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 16
Forward Instantiation Transformation
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




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

*'(*(x, s(s(x''''))), s(s(y''''))) -> *'(s(s(x'''')), s(s(y'''')))
five new Dependency Pairs are created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 17
Argument Filtering and Ordering
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pairs:

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


Rules:


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


Strategy:

innermost




The following dependency pairs can be strictly oriented:

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


The following usable rules for innermost can be oriented:

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


Used ordering: Lexicographic Path Order with Non-Strict Precedence with Quasi Precedence:
*' > * > + > s

resulting in one new DP problem.
Used Argument Filtering System:
*'(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
Nar
           →DP Problem 12
Nar
             ...
               →DP Problem 18
Dependency Graph
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst


Dependency Pair:


Rules:


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


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
Forward Instantiation Transformation
       →DP Problem 4
FwdInst


Dependency Pair:

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


Rules:


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


Strategy:

innermost




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

SUM(cons(x, l)) -> SUM(l)
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
           →DP Problem 19
Forward Instantiation Transformation
       →DP Problem 4
FwdInst


Dependency Pair:

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


Rules:


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


Strategy:

innermost




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

SUM(cons(x, cons(x'', l''))) -> SUM(cons(x'', l''))
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
           →DP Problem 19
FwdInst
             ...
               →DP Problem 20
Argument Filtering and Ordering
       →DP Problem 4
FwdInst


Dependency Pair:

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


Rules:


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


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


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

resulting in one new DP problem.
Used Argument Filtering System:
SUM(x1) -> SUM(x1)
cons(x1, x2) -> cons(x1, x2)


   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
           →DP Problem 19
FwdInst
             ...
               →DP Problem 21
Dependency Graph
       →DP Problem 4
FwdInst


Dependency Pair:


Rules:


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


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.


   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
Forward Instantiation Transformation


Dependency Pair:

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


Rules:


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


Strategy:

innermost




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

PROD(cons(x, l)) -> PROD(l)
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst
           →DP Problem 22
Forward Instantiation Transformation


Dependency Pair:

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


Rules:


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


Strategy:

innermost




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

PROD(cons(x, cons(x'', l''))) -> PROD(cons(x'', l''))
one new Dependency Pair is created:

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

The transformation is resulting in one new DP problem:



   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst
           →DP Problem 22
FwdInst
             ...
               →DP Problem 23
Argument Filtering and Ordering


Dependency Pair:

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


Rules:


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


Strategy:

innermost




The following dependency pair can be strictly oriented:

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


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

resulting in one new DP problem.
Used Argument Filtering System:
PROD(x1) -> PROD(x1)
cons(x1, x2) -> cons(x1, x2)


   R
DPs
       →DP Problem 1
Nar
       →DP Problem 2
Nar
       →DP Problem 3
FwdInst
       →DP Problem 4
FwdInst
           →DP Problem 22
FwdInst
             ...
               →DP Problem 24
Dependency Graph


Dependency Pair:


Rules:


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


Strategy:

innermost




Using the Dependency Graph resulted in no new DP problems.

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