YES

Problem:
 U11(tt(),V1,V2) -> U12(isNat(activate(V1)),activate(V2))
 U12(tt(),V2) -> U13(isNat(activate(V2)))
 U13(tt()) -> tt()
 U21(tt(),V1) -> U22(isNat(activate(V1)))
 U22(tt()) -> tt()
 U31(tt(),N) -> activate(N)
 U41(tt(),M,N) -> s(plus(activate(N),activate(M)))
 and(tt(),X) -> activate(X)
 isNat(n__0()) -> tt()
 isNat(n__plus(V1,V2)) ->
 U11(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),activate(V2))
 isNat(n__s(V1)) -> U21(isNatKind(activate(V1)),activate(V1))
 isNatKind(n__0()) -> tt()
 isNatKind(n__plus(V1,V2)) -> and(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
 isNatKind(n__s(V1)) -> isNatKind(activate(V1))
 plus(N,0()) -> U31(and(isNat(N),n__isNatKind(N)),N)
 plus(N,s(M)) -> U41(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),M,N)
 0() -> n__0()
 plus(X1,X2) -> n__plus(X1,X2)
 isNatKind(X) -> n__isNatKind(X)
 s(X) -> n__s(X)
 and(X1,X2) -> n__and(X1,X2)
 isNat(X) -> n__isNat(X)
 activate(n__0()) -> 0()
 activate(n__plus(X1,X2)) -> plus(activate(X1),activate(X2))
 activate(n__isNatKind(X)) -> isNatKind(X)
 activate(n__s(X)) -> s(activate(X))
 activate(n__and(X1,X2)) -> and(activate(X1),X2)
 activate(n__isNat(X)) -> isNat(X)
 activate(X) -> X

Proof:
 DP Processor:
  DPs:
   U11#(tt(),V1,V2) -> activate#(V2)
   U11#(tt(),V1,V2) -> activate#(V1)
   U11#(tt(),V1,V2) -> isNat#(activate(V1))
   U11#(tt(),V1,V2) -> U12#(isNat(activate(V1)),activate(V2))
   U12#(tt(),V2) -> activate#(V2)
   U12#(tt(),V2) -> isNat#(activate(V2))
   U12#(tt(),V2) -> U13#(isNat(activate(V2)))
   U21#(tt(),V1) -> activate#(V1)
   U21#(tt(),V1) -> isNat#(activate(V1))
   U21#(tt(),V1) -> U22#(isNat(activate(V1)))
   U31#(tt(),N) -> activate#(N)
   U41#(tt(),M,N) -> activate#(M)
   U41#(tt(),M,N) -> activate#(N)
   U41#(tt(),M,N) -> plus#(activate(N),activate(M))
   U41#(tt(),M,N) -> s#(plus(activate(N),activate(M)))
   and#(tt(),X) -> activate#(X)
   isNat#(n__plus(V1,V2)) -> activate#(V2)
   isNat#(n__plus(V1,V2)) -> activate#(V1)
   isNat#(n__plus(V1,V2)) -> isNatKind#(activate(V1))
   isNat#(n__plus(V1,V2)) -> and#(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
   isNat#(n__plus(V1,V2)) ->
   U11#(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),activate(V2))
   isNat#(n__s(V1)) -> activate#(V1)
   isNat#(n__s(V1)) -> isNatKind#(activate(V1))
   isNat#(n__s(V1)) -> U21#(isNatKind(activate(V1)),activate(V1))
   isNatKind#(n__plus(V1,V2)) -> activate#(V2)
   isNatKind#(n__plus(V1,V2)) -> activate#(V1)
   isNatKind#(n__plus(V1,V2)) -> isNatKind#(activate(V1))
   isNatKind#(n__plus(V1,V2)) -> and#(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
   isNatKind#(n__s(V1)) -> activate#(V1)
   isNatKind#(n__s(V1)) -> isNatKind#(activate(V1))
   plus#(N,0()) -> isNat#(N)
   plus#(N,0()) -> and#(isNat(N),n__isNatKind(N))
   plus#(N,0()) -> U31#(and(isNat(N),n__isNatKind(N)),N)
   plus#(N,s(M)) -> isNat#(M)
   plus#(N,s(M)) -> and#(isNat(M),n__isNatKind(M))
   plus#(N,s(M)) -> and#(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N)))
   plus#(N,s(M)) ->
   U41#(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),M,N)
   activate#(n__0()) -> 0#()
   activate#(n__plus(X1,X2)) -> activate#(X2)
   activate#(n__plus(X1,X2)) -> activate#(X1)
   activate#(n__plus(X1,X2)) -> plus#(activate(X1),activate(X2))
   activate#(n__isNatKind(X)) -> isNatKind#(X)
   activate#(n__s(X)) -> activate#(X)
   activate#(n__s(X)) -> s#(activate(X))
   activate#(n__and(X1,X2)) -> activate#(X1)
   activate#(n__and(X1,X2)) -> and#(activate(X1),X2)
   activate#(n__isNat(X)) -> isNat#(X)
  TRS:
   U11(tt(),V1,V2) -> U12(isNat(activate(V1)),activate(V2))
   U12(tt(),V2) -> U13(isNat(activate(V2)))
   U13(tt()) -> tt()
   U21(tt(),V1) -> U22(isNat(activate(V1)))
   U22(tt()) -> tt()
   U31(tt(),N) -> activate(N)
   U41(tt(),M,N) -> s(plus(activate(N),activate(M)))
   and(tt(),X) -> activate(X)
   isNat(n__0()) -> tt()
   isNat(n__plus(V1,V2)) ->
   U11(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),activate(V2))
   isNat(n__s(V1)) -> U21(isNatKind(activate(V1)),activate(V1))
   isNatKind(n__0()) -> tt()
   isNatKind(n__plus(V1,V2)) -> and(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
   isNatKind(n__s(V1)) -> isNatKind(activate(V1))
   plus(N,0()) -> U31(and(isNat(N),n__isNatKind(N)),N)
   plus(N,s(M)) -> U41(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),M,N)
   0() -> n__0()
   plus(X1,X2) -> n__plus(X1,X2)
   isNatKind(X) -> n__isNatKind(X)
   s(X) -> n__s(X)
   and(X1,X2) -> n__and(X1,X2)
   isNat(X) -> n__isNat(X)
   activate(n__0()) -> 0()
   activate(n__plus(X1,X2)) -> plus(activate(X1),activate(X2))
   activate(n__isNatKind(X)) -> isNatKind(X)
   activate(n__s(X)) -> s(activate(X))
   activate(n__and(X1,X2)) -> and(activate(X1),X2)
   activate(n__isNat(X)) -> isNat(X)
   activate(X) -> X
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [0#] = 0,
    
    [isNatKind#](x0) = 2x0,
    
    [and#](x0, x1) = 2x1 + 2,
    
    [s#](x0) = 4,
    
    [plus#](x0, x1) = 6x0 + 2x1 + 5,
    
    [U41#](x0, x1, x2) = 2x1 + 6x2 + 6,
    
    [U31#](x0, x1) = 6x1 + 4,
    
    [U22#](x0) = x0,
    
    [U21#](x0, x1) = 2x1 + 4,
    
    [U13#](x0) = 4x0 + 4,
    
    [U12#](x0, x1) = 4x1 + 5,
    
    [isNat#](x0) = 2x0,
    
    [activate#](x0) = 2x0 + 1,
    
    [U11#](x0, x1, x2) = 4x1 + 4x2 + 7,
    
    [n__and](x0, x1) = 2x0 + x1 + 2,
    
    [n__isNat](x0) = x0,
    
    [0] = 3,
    
    [n__s](x0) = x0 + 3,
    
    [n__isNatKind](x0) = x0 + 1,
    
    [isNatKind](x0) = x0 + 1,
    
    [n__plus](x0, x1) = 3x0 + 2x1 + 4,
    
    [n__0] = 3,
    
    [and](x0, x1) = 2x0 + x1 + 2,
    
    [s](x0) = x0 + 3,
    
    [plus](x0, x1) = 3x0 + 2x1 + 4,
    
    [U41](x0, x1, x2) = 2x1 + 3x2 + 7,
    
    [U31](x0, x1) = 3x1 + 1,
    
    [U22](x0) = 1,
    
    [U21](x0, x1) = x0 + 2,
    
    [U13](x0) = 0,
    
    [U12](x0, x1) = 3x0,
    
    [isNat](x0) = x0,
    
    [activate](x0) = x0,
    
    [U11](x0, x1, x2) = 3x1 + 2x2,
    
    [tt] = 0
   orientation:
    U11#(tt(),V1,V2) = 4V1 + 4V2 + 7 >= 2V2 + 1 = activate#(V2)
    
    U11#(tt(),V1,V2) = 4V1 + 4V2 + 7 >= 2V1 + 1 = activate#(V1)
    
    U11#(tt(),V1,V2) = 4V1 + 4V2 + 7 >= 2V1 = isNat#(activate(V1))
    
    U11#(tt(),V1,V2) = 4V1 + 4V2 + 7 >= 4V2 + 5 = U12#(isNat(activate(V1)),activate(V2))
    
    U12#(tt(),V2) = 4V2 + 5 >= 2V2 + 1 = activate#(V2)
    
    U12#(tt(),V2) = 4V2 + 5 >= 2V2 = isNat#(activate(V2))
    
    U12#(tt(),V2) = 4V2 + 5 >= 4V2 + 4 = U13#(isNat(activate(V2)))
    
    U21#(tt(),V1) = 2V1 + 4 >= 2V1 + 1 = activate#(V1)
    
    U21#(tt(),V1) = 2V1 + 4 >= 2V1 = isNat#(activate(V1))
    
    U21#(tt(),V1) = 2V1 + 4 >= V1 = U22#(isNat(activate(V1)))
    
    U31#(tt(),N) = 6N + 4 >= 2N + 1 = activate#(N)
    
    U41#(tt(),M,N) = 2M + 6N + 6 >= 2M + 1 = activate#(M)
    
    U41#(tt(),M,N) = 2M + 6N + 6 >= 2N + 1 = activate#(N)
    
    U41#(tt(),M,N) = 2M + 6N + 6 >= 2M + 6N + 5 = plus#(activate(N),activate(M))
    
    U41#(tt(),M,N) = 2M + 6N + 6 >= 4 = s#(plus(activate(N),activate(M)))
    
    and#(tt(),X) = 2X + 2 >= 2X + 1 = activate#(X)
    
    isNat#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V2 + 1 = activate#(V2)
    
    isNat#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V1 + 1 = activate#(V1)
    
    isNat#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V1 = isNatKind#(activate(V1))
    
    isNat#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V2 + 4 = and#(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
    
    isNat#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 4V1 + 4V2 + 7 = U11#(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),
     activate(V2))
    
    isNat#(n__s(V1)) = 2V1 + 6 >= 2V1 + 1 = activate#(V1)
    
    isNat#(n__s(V1)) = 2V1 + 6 >= 2V1 = isNatKind#(activate(V1))
    
    isNat#(n__s(V1)) = 2V1 + 6 >= 2V1 + 4 = U21#(isNatKind(activate(V1)),activate(V1))
    
    isNatKind#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V2 + 1 = activate#(V2)
    
    isNatKind#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V1 + 1 = activate#(V1)
    
    isNatKind#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V1 = isNatKind#(activate(V1))
    
    isNatKind#(n__plus(V1,V2)) = 6V1 + 4V2 + 8 >= 2V2 + 4 = and#(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
    
    isNatKind#(n__s(V1)) = 2V1 + 6 >= 2V1 + 1 = activate#(V1)
    
    isNatKind#(n__s(V1)) = 2V1 + 6 >= 2V1 = isNatKind#(activate(V1))
    
    plus#(N,0()) = 6N + 11 >= 2N = isNat#(N)
    
    plus#(N,0()) = 6N + 11 >= 2N + 4 = and#(isNat(N),n__isNatKind(N))
    
    plus#(N,0()) = 6N + 11 >= 6N + 4 = U31#(and(isNat(N),n__isNatKind(N)),N)
    
    plus#(N,s(M)) = 2M + 6N + 11 >= 2M = isNat#(M)
    
    plus#(N,s(M)) = 2M + 6N + 11 >= 2M + 4 = and#(isNat(M),n__isNatKind(M))
    
    plus#(N,s(M)) = 2M + 6N + 11 >= 6N + 8 = and#(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N)))
    
    plus#(N,s(M)) = 2M + 6N + 11 >= 2M + 6N + 6 = U41#(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),
     M,N)
    
    activate#(n__0()) = 7 >= 0 = 0#()
    
    activate#(n__plus(X1,X2)) = 6X1 + 4X2 + 9 >= 2X2 + 1 = activate#(X2)
    
    activate#(n__plus(X1,X2)) = 6X1 + 4X2 + 9 >= 2X1 + 1 = activate#(X1)
    
    activate#(n__plus(X1,X2)) = 6X1 + 4X2 + 9 >= 6X1 + 2X2 + 5 = plus#(activate(X1),activate(X2))
    
    activate#(n__isNatKind(X)) = 2X + 3 >= 2X = isNatKind#(X)
    
    activate#(n__s(X)) = 2X + 7 >= 2X + 1 = activate#(X)
    
    activate#(n__s(X)) = 2X + 7 >= 4 = s#(activate(X))
    
    activate#(n__and(X1,X2)) = 4X1 + 2X2 + 5 >= 2X1 + 1 = activate#(X1)
    
    activate#(n__and(X1,X2)) = 4X1 + 2X2 + 5 >= 2X2 + 2 = and#(activate(X1),X2)
    
    activate#(n__isNat(X)) = 2X + 1 >= 2X = isNat#(X)
    
    U11(tt(),V1,V2) = 3V1 + 2V2 >= 3V1 = U12(isNat(activate(V1)),activate(V2))
    
    U12(tt(),V2) = 0 >= 0 = U13(isNat(activate(V2)))
    
    U13(tt()) = 0 >= 0 = tt()
    
    U21(tt(),V1) = 2 >= 1 = U22(isNat(activate(V1)))
    
    U22(tt()) = 1 >= 0 = tt()
    
    U31(tt(),N) = 3N + 1 >= N = activate(N)
    
    U41(tt(),M,N) = 2M + 3N + 7 >= 2M + 3N + 7 = s(plus(activate(N),activate(M)))
    
    and(tt(),X) = X + 2 >= X = activate(X)
    
    isNat(n__0()) = 3 >= 0 = tt()
    
    isNat(n__plus(V1,V2)) = 3V1 + 2V2 + 4 >= 3V1 + 2V2 = U11(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),
    activate(V2))
    
    isNat(n__s(V1)) = V1 + 3 >= V1 + 3 = U21(isNatKind(activate(V1)),activate(V1))
    
    isNatKind(n__0()) = 4 >= 0 = tt()
    
    isNatKind(n__plus(V1,V2)) = 3V1 + 2V2 + 5 >= 2V1 + V2 + 5 = and(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
    
    isNatKind(n__s(V1)) = V1 + 4 >= V1 + 1 = isNatKind(activate(V1))
    
    plus(N,0()) = 3N + 10 >= 3N + 1 = U31(and(isNat(N),n__isNatKind(N)),N)
    
    plus(N,s(M)) = 2M + 3N + 10 >= 2M + 3N + 7 = U41(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),
    M,N)
    
    0() = 3 >= 3 = n__0()
    
    plus(X1,X2) = 3X1 + 2X2 + 4 >= 3X1 + 2X2 + 4 = n__plus(X1,X2)
    
    isNatKind(X) = X + 1 >= X + 1 = n__isNatKind(X)
    
    s(X) = X + 3 >= X + 3 = n__s(X)
    
    and(X1,X2) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = n__and(X1,X2)
    
    isNat(X) = X >= X = n__isNat(X)
    
    activate(n__0()) = 3 >= 3 = 0()
    
    activate(n__plus(X1,X2)) = 3X1 + 2X2 + 4 >= 3X1 + 2X2 + 4 = plus(activate(X1),activate(X2))
    
    activate(n__isNatKind(X)) = X + 1 >= X + 1 = isNatKind(X)
    
    activate(n__s(X)) = X + 3 >= X + 3 = s(activate(X))
    
    activate(n__and(X1,X2)) = 2X1 + X2 + 2 >= 2X1 + X2 + 2 = and(activate(X1),X2)
    
    activate(n__isNat(X)) = X >= X = isNat(X)
    
    activate(X) = X >= X = X
   problem:
    DPs:
     
    TRS:
     U11(tt(),V1,V2) -> U12(isNat(activate(V1)),activate(V2))
     U12(tt(),V2) -> U13(isNat(activate(V2)))
     U13(tt()) -> tt()
     U21(tt(),V1) -> U22(isNat(activate(V1)))
     U22(tt()) -> tt()
     U31(tt(),N) -> activate(N)
     U41(tt(),M,N) -> s(plus(activate(N),activate(M)))
     and(tt(),X) -> activate(X)
     isNat(n__0()) -> tt()
     isNat(n__plus(V1,V2)) ->
     U11(and(isNatKind(activate(V1)),n__isNatKind(activate(V2))),activate(V1),activate(V2))
     isNat(n__s(V1)) -> U21(isNatKind(activate(V1)),activate(V1))
     isNatKind(n__0()) -> tt()
     isNatKind(n__plus(V1,V2)) -> and(isNatKind(activate(V1)),n__isNatKind(activate(V2)))
     isNatKind(n__s(V1)) -> isNatKind(activate(V1))
     plus(N,0()) -> U31(and(isNat(N),n__isNatKind(N)),N)
     plus(N,s(M)) ->
     U41(and(and(isNat(M),n__isNatKind(M)),n__and(n__isNat(N),n__isNatKind(N))),M,N)
     0() -> n__0()
     plus(X1,X2) -> n__plus(X1,X2)
     isNatKind(X) -> n__isNatKind(X)
     s(X) -> n__s(X)
     and(X1,X2) -> n__and(X1,X2)
     isNat(X) -> n__isNat(X)
     activate(n__0()) -> 0()
     activate(n__plus(X1,X2)) -> plus(activate(X1),activate(X2))
     activate(n__isNatKind(X)) -> isNatKind(X)
     activate(n__s(X)) -> s(activate(X))
     activate(n__and(X1,X2)) -> and(activate(X1),X2)
     activate(n__isNat(X)) -> isNat(X)
     activate(X) -> X
   Qed