Term Rewriting System R:
[X, Y, DX, DY, DDX]
din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)

Innermost Termination of R to be shown. 



   R
     ↳Dependency Pair Analysis



R contains the following Dependency Pairs:

DIN(der(plus(X, Y))) -> U21(din(der(X)), X, Y)
DIN(der(plus(X, Y))) -> DIN(der(X))
DIN(der(times(X, Y))) -> U31(din(der(X)), X, Y)
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(der(X))) -> U41(din(der(X)), X)
DIN(der(der(X))) -> DIN(der(X))
U21(dout(DX), X, Y) -> U22(din(der(Y)), X, Y, DX)
U21(dout(DX), X, Y) -> DIN(der(Y))
U31(dout(DX), X, Y) -> U32(din(der(Y)), X, Y, DX)
U31(dout(DX), X, Y) -> DIN(der(Y))
U41(dout(DX), X) -> U42(din(der(DX)), X, DX)
U41(dout(DX), X) -> DIN(der(DX))

Furthermore, R contains one SCC. 


   R
     ↳DPs
       →DP Problem 1
         ↳Narrowing Transformation


Dependency Pairs:

DIN(der(der(X))) -> DIN(der(X))
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(X))) -> U41(din(der(X)), X)
DIN(der(times(X, Y))) -> DIN(der(X))
U31(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(times(X, Y))) -> U31(din(der(X)), X, Y)
DIN(der(plus(X, Y))) -> DIN(der(X))
U21(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(plus(X, Y))) -> U21(din(der(X)), X, Y)


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

DIN(der(plus(X, Y))) -> U21(din(der(X)), X, Y)
three new Dependency Pairs are created:

DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Narrowing Transformation


Dependency Pairs:

DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U21(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(X))) -> U41(din(der(X)), X)
DIN(der(times(X, Y))) -> DIN(der(X))
U31(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(times(X, Y))) -> U31(din(der(X)), X, Y)
DIN(der(plus(X, Y))) -> DIN(der(X))
DIN(der(der(X))) -> DIN(der(X))


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

DIN(der(times(X, Y))) -> U31(din(der(X)), X, Y)
three new Dependency Pairs are created:

DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 3
                 ↳Narrowing Transformation


Dependency Pairs:

DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U31(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(der(X))) -> DIN(der(X))
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(X))) -> U41(din(der(X)), X)
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(plus(X, Y))) -> DIN(der(X))
U21(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

DIN(der(der(X))) -> U41(din(der(X)), X)
three new Dependency Pairs are created:

DIN(der(der(plus(X'', Y')))) -> U41(u21(din(der(X'')), X'', Y'), plus(X'', Y'))
DIN(der(der(times(X'', Y')))) -> U41(u31(din(der(X'')), X'', Y'), times(X'', Y'))
DIN(der(der(der(X'')))) -> U41(u41(din(der(X'')), X''), der(X''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 4
                 ↳Instantiation Transformation


Dependency Pairs:

DIN(der(der(der(X'')))) -> U41(u41(din(der(X'')), X''), der(X''))
DIN(der(der(times(X'', Y')))) -> U41(u31(din(der(X'')), X'', Y'), times(X'', Y'))
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(plus(X'', Y')))) -> U41(u21(din(der(X'')), X'', Y'), plus(X'', Y'))
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U21(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(der(X))) -> DIN(der(X))
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(plus(X, Y))) -> DIN(der(X))
U31(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

U21(dout(DX), X, Y) -> DIN(der(Y))
three new Dependency Pairs are created:

U21(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
U21(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
U21(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 5
                 ↳Instantiation Transformation


Dependency Pairs:

DIN(der(der(times(X'', Y')))) -> U41(u31(din(der(X'')), X'', Y'), times(X'', Y'))
DIN(der(der(plus(X'', Y')))) -> U41(u21(din(der(X'')), X'', Y'), plus(X'', Y'))
DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U31(dout(DX), X, Y) -> DIN(der(Y))
DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
U21(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)
U21(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U21(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(der(X))) -> DIN(der(X))
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(plus(X, Y))) -> DIN(der(X))
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(der(X'')))) -> U41(u41(din(der(X'')), X''), der(X''))


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

U31(dout(DX), X, Y) -> DIN(der(Y))
three new Dependency Pairs are created:

U31(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
U31(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
U31(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 6
                 ↳Instantiation Transformation


Dependency Pairs:

DIN(der(der(der(X'')))) -> U41(u41(din(der(X'')), X''), der(X''))
DIN(der(der(plus(X'', Y')))) -> U41(u21(din(der(X'')), X'', Y'), plus(X'', Y'))
U31(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))
DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)
U31(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U31(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
U21(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)
U21(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U21(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(der(X))) -> DIN(der(X))
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(plus(X, Y))) -> DIN(der(X))
U41(dout(DX), X) -> DIN(der(DX))
DIN(der(der(times(X'', Y')))) -> U41(u31(din(der(X'')), X'', Y'), times(X'', Y'))


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost




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

U41(dout(DX), X) -> DIN(der(DX))
three new Dependency Pairs are created:

U41(dout(DX'), plus(X'''', Y''')) -> DIN(der(DX'))
U41(dout(DX'), times(X'''', Y''')) -> DIN(der(DX'))
U41(dout(DX'), der(X'''')) -> DIN(der(DX'))

The transformation is resulting in one new DP problem: 



   R
     ↳DPs
       →DP Problem 1
         ↳Nar
           →DP Problem 2
             ↳Nar
             ...
               →DP Problem 7
                 ↳Remaining Obligation(s)




The following remains to be proven:
Dependency Pairs:

U41(dout(DX'), times(X'''', Y''')) -> DIN(der(DX'))
DIN(der(der(times(X'', Y')))) -> U41(u31(din(der(X'')), X'', Y'), times(X'', Y'))
U41(dout(DX'), plus(X'''', Y''')) -> DIN(der(DX'))
DIN(der(der(plus(X'', Y')))) -> U41(u21(din(der(X'')), X'', Y'), plus(X'', Y'))
U31(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))
DIN(der(times(der(X''), Y))) -> U31(u41(din(der(X'')), X''), der(X''), Y)
U31(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(times(times(X'', Y''), Y))) -> U31(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U31(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(times(plus(X'', Y''), Y))) -> U31(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
U21(dout(DX'), der(X''''), Y'') -> DIN(der(Y''))
DIN(der(plus(der(X''), Y))) -> U21(u41(din(der(X'')), X''), der(X''), Y)
U21(dout(DX'), times(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(times(X'', Y''), Y))) -> U21(u31(din(der(X'')), X'', Y''), times(X'', Y''), Y)
U21(dout(DX'), plus(X'''', Y''''), Y'') -> DIN(der(Y''))
DIN(der(plus(plus(X'', Y''), Y))) -> U21(u21(din(der(X'')), X'', Y''), plus(X'', Y''), Y)
DIN(der(der(X))) -> DIN(der(X))
DIN(der(times(X, Y))) -> DIN(der(X))
DIN(der(plus(X, Y))) -> DIN(der(X))
U41(dout(DX'), der(X'''')) -> DIN(der(DX'))
DIN(der(der(der(X'')))) -> U41(u41(din(der(X'')), X''), der(X''))


Rules:


din(der(plus(X, Y))) -> u21(din(der(X)), X, Y)
din(der(times(X, Y))) -> u31(din(der(X)), X, Y)
din(der(der(X))) -> u41(din(der(X)), X)
u21(dout(DX), X, Y) -> u22(din(der(Y)), X, Y, DX)
u22(dout(DY), X, Y, DX) -> dout(plus(DX, DY))
u31(dout(DX), X, Y) -> u32(din(der(Y)), X, Y, DX)
u32(dout(DY), X, Y, DX) -> dout(plus(times(X, DY), times(Y, DX)))
u41(dout(DX), X) -> u42(din(der(DX)), X, DX)
u42(dout(DDX), X, DX) -> dout(DDX)


Strategy:

innermost



Innermost Termination of R could not be shown.
Duration:
0:14 minutes