/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Problem 1: 

(VAR DDX DX DY X Y)
(RULES
din(der(der(X))) -> u41(din(der(X)),X)
din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
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)
)

Problem 1: 

Innermost Equivalent Processor:
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> The term rewriting system is non-overlaping or locally confluent overlay system. Therefore, innermost termination implies termination.
 

Problem 1: 

Dependency Pairs Processor:
-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(der(X))) -> U41(din(der(X)),X)
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U21(dout(DX),X,Y) -> U22(din(der(Y)),X,Y,DX)
 U31(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> U32(din(der(Y)),X,Y,DX)
 U41(dout(DX),X) -> DIN(der(DX))
 U41(dout(DX),X) -> U42(din(der(DX)),X,DX)
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(der(X))) -> U41(din(der(X)),X)
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U21(dout(DX),X,Y) -> U22(din(der(Y)),X,Y,DX)
 U31(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> U32(din(der(Y)),X,Y,DX)
 U41(dout(DX),X) -> DIN(der(DX))
 U41(dout(DX),X) -> U42(din(der(DX)),X,DX)
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(der(X))) -> U41(din(der(X)),X)
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
 U41(dout(DX),X) -> DIN(der(DX))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(der(X))) -> U41(din(der(X)),X)
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
 U41(dout(DX),X) -> DIN(der(DX))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = X
[u21](X1,X2,X3) = 1
[u22](X1,X2,X3,X4) = X1
[u31](X1,X2,X3) = X1
[u32](X1,X2,X3,X4) = 2.X1
[u41](X1,X2) = X1
[u42](X1,X2,X3) = 2
[der](X) = 1
[dout](X) = 2
[plus](X1,X2) = 2
[times](X1,X2) = 2
[DIN](X) = 2.X
[U21](X1,X2,X3) = 2
[U31](X1,X2,X3) = X1 + 1
[U41](X1,X2) = X1

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
 U41(dout(DX),X) -> DIN(der(DX))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(der(X))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = 2.X
[u21](X1,X2,X3) = 2.X1 + X3
[u22](X1,X2,X3,X4) = X3 + 2
[u31](X1,X2,X3) = 2.X2 + 2
[u32](X1,X2,X3,X4) = 2.X2 + 2
[u41](X1,X2) = 2
[u42](X1,X2,X3) = 2
[der](X) = X + 2
[dout](X) = 2
[plus](X1,X2) = 2.X1 + 2.X2 + 2
[times](X1,X2) = 2.X1 + 2.X2 + 2
[DIN](X) = 2.X + 2
[U21](X1,X2,X3) = 2.X1 + 2.X3 + 2
[U31](X1,X2,X3) = 2.X1 + 2.X3 + 2

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(plus(X,Y))) -> DIN(der(X))
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = 0
[u21](X1,X2,X3) = 2.X1
[u22](X1,X2,X3,X4) = 2.X1 + 2
[u31](X1,X2,X3) = 2.X1
[u32](X1,X2,X3,X4) = 2
[u41](X1,X2) = 2.X1
[u42](X1,X2,X3) = 2.X1 + 2
[der](X) = 2.X + 2
[dout](X) = 2
[plus](X1,X2) = 2.X1 + 2.X2 + 2
[times](X1,X2) = 2.X1 + 2.X2 + 2
[DIN](X) = X + 2
[U21](X1,X2,X3) = X1 + 2.X2 + 2.X3 + 2
[U31](X1,X2,X3) = X1 + X2 + 2.X3 + 2

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(plus(X,Y))) -> U21(din(der(X)),X,Y)
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = X
[u21](X1,X2,X3) = X1
[u22](X1,X2,X3,X4) = 2
[u31](X1,X2,X3) = 1
[u32](X1,X2,X3,X4) = X1
[u41](X1,X2) = 1
[u42](X1,X2,X3) = X1
[der](X) = 1
[dout](X) = 2
[plus](X1,X2) = 2.X1
[times](X1,X2) = 0
[DIN](X) = 2
[U21](X1,X2,X3) = X1
[U31](X1,X2,X3) = 2

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U21(dout(DX),X,Y) -> DIN(der(Y))
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U31(dout(DX),X,Y) -> DIN(der(Y))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(times(X,Y))) -> DIN(der(X))
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = 2.X + 2
[u21](X1,X2,X3) = 2.X1 + 2
[u22](X1,X2,X3,X4) = 2
[u31](X1,X2,X3) = 2.X1 + X3 + 2
[u32](X1,X2,X3,X4) = X3 + 2
[u41](X1,X2) = 2.X2 + 2
[u42](X1,X2,X3) = 2.X2 + 2
[der](X) = X
[dout](X) = 2
[plus](X1,X2) = 2.X1 + 2
[times](X1,X2) = 2.X1 + 2.X2 + 2
[DIN](X) = 2.X + 2
[U31](X1,X2,X3) = 2.X2 + 2.X3 + 2

Problem 1: 

SCC Processor:
-> Pairs:
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
->->Cycle:
->->-> Pairs:
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U31(dout(DX),X,Y) -> DIN(der(Y))
->->-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)

Problem 1: 

Reduction Pairs Processor:
-> Pairs:
 DIN(der(times(X,Y))) -> U31(din(der(X)),X,Y)
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
-> Usable rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Interpretation type:
 Linear
->Coefficients:
 Natural Numbers
->Dimension:
 1
->Bound:
 2
->Interpretation:
 
[din](X) = 1
[u21](X1,X2,X3) = X1
[u22](X1,X2,X3,X4) = 2.X1
[u31](X1,X2,X3) = X1
[u32](X1,X2,X3,X4) = 2.X1
[u41](X1,X2) = 1
[u42](X1,X2,X3) = X1
[der](X) = 2.X + 2
[dout](X) = 2
[plus](X1,X2) = X1 + X2 + 2
[times](X1,X2) = X1 + X2 + 2
[DIN](X) = X
[U31](X1,X2,X3) = 2.X2 + 2.X3 + 2

Problem 1: 

SCC Processor:
-> Pairs:
 U31(dout(DX),X,Y) -> DIN(der(Y))
-> Rules:
 din(der(der(X))) -> u41(din(der(X)),X)
 din(der(plus(X,Y))) -> u21(din(der(X)),X,Y)
 din(der(times(X,Y))) -> u31(din(der(X)),X,Y)
 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)
->Strongly Connected Components:
 There is no strongly connected component

The problem is finite.