YES
TRS:
 {                            from(X) -> cons(X, n__from(n__s(X))),
                              from(X) -> n__from(X),
                      2ndspos(0(), Z) -> rnil(),
            2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
  2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                 s(X) -> n__s(X),
                          activate(X) -> X,
                 activate(n__from(X)) -> from(activate(X)),
                    activate(n__s(X)) -> s(activate(X)),
                      2ndsneg(0(), Z) -> rnil(),
            2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
  2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                pi(X) -> 2ndspos(X, from(0())),
                         plus(0(), Y) -> Y,
                        plus(s(X), Y) -> s(plus(X, Y)),
                        times(0(), Y) -> 0(),
                       times(s(X), Y) -> plus(Y, times(X, Y)),
                            square(X) -> times(X, X)}
 DP:
  Strict:
   {          2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))),
              2ndspos#(s(N), cons(X, Z)) -> activate#(Z),
    2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z),
    2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)),
                   activate#(n__from(X)) -> from#(activate(X)),
                   activate#(n__from(X)) -> activate#(X),
                      activate#(n__s(X)) -> s#(activate(X)),
                      activate#(n__s(X)) -> activate#(X),
              2ndsneg#(s(N), cons(X, Z)) -> activate#(Z),
              2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))),
    2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)),
    2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z),
                                  pi#(X) -> from#(0()),
                                  pi#(X) -> 2ndspos#(X, from(0())),
                          plus#(s(X), Y) -> s#(plus(X, Y)),
                          plus#(s(X), Y) -> plus#(X, Y),
                         times#(s(X), Y) -> plus#(Y, times(X, Y)),
                         times#(s(X), Y) -> times#(X, Y),
                              square#(X) -> times#(X, X)}
  Weak:
  {                            from(X) -> cons(X, n__from(n__s(X))),
                               from(X) -> n__from(X),
                       2ndspos(0(), Z) -> rnil(),
             2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
   2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                  s(X) -> n__s(X),
                           activate(X) -> X,
                  activate(n__from(X)) -> from(activate(X)),
                     activate(n__s(X)) -> s(activate(X)),
                       2ndsneg(0(), Z) -> rnil(),
             2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
   2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                 pi(X) -> 2ndspos(X, from(0())),
                          plus(0(), Y) -> Y,
                         plus(s(X), Y) -> s(plus(X, Y)),
                         times(0(), Y) -> 0(),
                        times(s(X), Y) -> plus(Y, times(X, Y)),
                             square(X) -> times(X, X)}
  EDG:
   {(2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))), 2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z))
    (2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))), 2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)))
    (times#(s(X), Y) -> times#(X, Y), times#(s(X), Y) -> times#(X, Y))
    (times#(s(X), Y) -> times#(X, Y), times#(s(X), Y) -> plus#(Y, times(X, Y)))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)), 2ndspos#(s(N), cons(X, Z)) -> activate#(Z))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)), 2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))))
    (2ndspos#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__s(X)) -> activate#(X))
    (2ndspos#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__s(X)) -> s#(activate(X)))
    (2ndspos#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__from(X)) -> activate#(X))
    (2ndspos#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__from(X)) -> from#(activate(X)))
    (2ndsneg#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__s(X)) -> activate#(X))
    (2ndsneg#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__s(X)) -> s#(activate(X)))
    (2ndsneg#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__from(X)) -> activate#(X))
    (2ndsneg#(s(N), cons(X, Z)) -> activate#(Z), activate#(n__from(X)) -> from#(activate(X)))
    (square#(X) -> times#(X, X), times#(s(X), Y) -> times#(X, Y))
    (square#(X) -> times#(X, X), times#(s(X), Y) -> plus#(Y, times(X, Y)))
    (activate#(n__from(X)) -> activate#(X), activate#(n__s(X)) -> activate#(X))
    (activate#(n__from(X)) -> activate#(X), activate#(n__s(X)) -> s#(activate(X)))
    (activate#(n__from(X)) -> activate#(X), activate#(n__from(X)) -> activate#(X))
    (activate#(n__from(X)) -> activate#(X), activate#(n__from(X)) -> from#(activate(X)))
    (activate#(n__s(X)) -> activate#(X), activate#(n__from(X)) -> from#(activate(X)))
    (activate#(n__s(X)) -> activate#(X), activate#(n__from(X)) -> activate#(X))
    (activate#(n__s(X)) -> activate#(X), activate#(n__s(X)) -> s#(activate(X)))
    (activate#(n__s(X)) -> activate#(X), activate#(n__s(X)) -> activate#(X))
    (pi#(X) -> 2ndspos#(X, from(0())), 2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))))
    (pi#(X) -> 2ndspos#(X, from(0())), 2ndspos#(s(N), cons(X, Z)) -> activate#(Z))
    (pi#(X) -> 2ndspos#(X, from(0())), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z))
    (pi#(X) -> 2ndspos#(X, from(0())), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)))
    (times#(s(X), Y) -> plus#(Y, times(X, Y)), plus#(s(X), Y) -> s#(plus(X, Y)))
    (times#(s(X), Y) -> plus#(Y, times(X, Y)), plus#(s(X), Y) -> plus#(X, Y))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__from(X)) -> from#(activate(X)))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__from(X)) -> activate#(X))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__s(X)) -> s#(activate(X)))
    (2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__s(X)) -> activate#(X))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__from(X)) -> from#(activate(X)))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__from(X)) -> activate#(X))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__s(X)) -> s#(activate(X)))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z), activate#(n__s(X)) -> activate#(X))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)), 2ndsneg#(s(N), cons(X, Z)) -> activate#(Z))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)), 2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)), 2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z)))
    (2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)), 2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z))
    (plus#(s(X), Y) -> plus#(X, Y), plus#(s(X), Y) -> s#(plus(X, Y)))
    (plus#(s(X), Y) -> plus#(X, Y), plus#(s(X), Y) -> plus#(X, Y))
    (2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> activate#(Z))
    (2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)))}
   SCCS:
    Scc:
     {times#(s(X), Y) -> times#(X, Y)}
    Scc:
     {plus#(s(X), Y) -> plus#(X, Y)}
    Scc:
     {activate#(n__from(X)) -> activate#(X),
         activate#(n__s(X)) -> activate#(X)}
    Scc:
     {          2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))),
      2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)),
                2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))),
      2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z))}
    SCC:
     Strict:
      {times#(s(X), Y) -> times#(X, Y)}
     Weak:
     {                            from(X) -> cons(X, n__from(n__s(X))),
                                  from(X) -> n__from(X),
                          2ndspos(0(), Z) -> rnil(),
                2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
      2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                     s(X) -> n__s(X),
                              activate(X) -> X,
                     activate(n__from(X)) -> from(activate(X)),
                        activate(n__s(X)) -> s(activate(X)),
                          2ndsneg(0(), Z) -> rnil(),
                2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
      2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                    pi(X) -> 2ndspos(X, from(0())),
                             plus(0(), Y) -> Y,
                            plus(s(X), Y) -> s(plus(X, Y)),
                            times(0(), Y) -> 0(),
                           times(s(X), Y) -> plus(Y, times(X, Y)),
                                square(X) -> times(X, X)}
     SPSC:
      Simple Projection:
       pi(times#) = 0
      Strict:
       {}
      Qed
    SCC:
     Strict:
      {plus#(s(X), Y) -> plus#(X, Y)}
     Weak:
     {                            from(X) -> cons(X, n__from(n__s(X))),
                                  from(X) -> n__from(X),
                          2ndspos(0(), Z) -> rnil(),
                2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
      2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                     s(X) -> n__s(X),
                              activate(X) -> X,
                     activate(n__from(X)) -> from(activate(X)),
                        activate(n__s(X)) -> s(activate(X)),
                          2ndsneg(0(), Z) -> rnil(),
                2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
      2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                    pi(X) -> 2ndspos(X, from(0())),
                             plus(0(), Y) -> Y,
                            plus(s(X), Y) -> s(plus(X, Y)),
                            times(0(), Y) -> 0(),
                           times(s(X), Y) -> plus(Y, times(X, Y)),
                                square(X) -> times(X, X)}
     SPSC:
      Simple Projection:
       pi(plus#) = 0
      Strict:
       {}
      Qed
    SCC:
     Strict:
      {activate#(n__from(X)) -> activate#(X),
          activate#(n__s(X)) -> activate#(X)}
     Weak:
     {                            from(X) -> cons(X, n__from(n__s(X))),
                                  from(X) -> n__from(X),
                          2ndspos(0(), Z) -> rnil(),
                2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
      2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                     s(X) -> n__s(X),
                              activate(X) -> X,
                     activate(n__from(X)) -> from(activate(X)),
                        activate(n__s(X)) -> s(activate(X)),
                          2ndsneg(0(), Z) -> rnil(),
                2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
      2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                    pi(X) -> 2ndspos(X, from(0())),
                             plus(0(), Y) -> Y,
                            plus(s(X), Y) -> s(plus(X, Y)),
                            times(0(), Y) -> 0(),
                           times(s(X), Y) -> plus(Y, times(X, Y)),
                                square(X) -> times(X, X)}
     SPSC:
      Simple Projection:
       pi(activate#) = 0
      Strict:
       {activate#(n__s(X)) -> activate#(X)}
      EDG:
       {(activate#(n__s(X)) -> activate#(X), activate#(n__s(X)) -> activate#(X))}
       SCCS:
        Scc:
         {activate#(n__s(X)) -> activate#(X)}
        SCC:
         Strict:
          {activate#(n__s(X)) -> activate#(X)}
         Weak:
         {                            from(X) -> cons(X, n__from(n__s(X))),
                                      from(X) -> n__from(X),
                              2ndspos(0(), Z) -> rnil(),
                    2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
          2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                         s(X) -> n__s(X),
                                  activate(X) -> X,
                         activate(n__from(X)) -> from(activate(X)),
                            activate(n__s(X)) -> s(activate(X)),
                              2ndsneg(0(), Z) -> rnil(),
                    2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
          2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                        pi(X) -> 2ndspos(X, from(0())),
                                 plus(0(), Y) -> Y,
                                plus(s(X), Y) -> s(plus(X, Y)),
                                times(0(), Y) -> 0(),
                               times(s(X), Y) -> plus(Y, times(X, Y)),
                                    square(X) -> times(X, X)}
         SPSC:
          Simple Projection:
           pi(activate#) = 0
          Strict:
           {}
          Qed
    SCC:
     Strict:
      {          2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))),
       2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)),
                 2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))),
       2ndsneg#(s(N), cons2(X, cons(Y, Z))) -> 2ndspos#(N, activate(Z))}
     Weak:
     {                            from(X) -> cons(X, n__from(n__s(X))),
                                  from(X) -> n__from(X),
                          2ndspos(0(), Z) -> rnil(),
                2ndspos(s(N), cons(X, Z)) -> 2ndspos(s(N), cons2(X, activate(Z))),
      2ndspos(s(N), cons2(X, cons(Y, Z))) -> rcons(posrecip(Y), 2ndsneg(N, activate(Z))),
                                     s(X) -> n__s(X),
                              activate(X) -> X,
                     activate(n__from(X)) -> from(activate(X)),
                        activate(n__s(X)) -> s(activate(X)),
                          2ndsneg(0(), Z) -> rnil(),
                2ndsneg(s(N), cons(X, Z)) -> 2ndsneg(s(N), cons2(X, activate(Z))),
      2ndsneg(s(N), cons2(X, cons(Y, Z))) -> rcons(negrecip(Y), 2ndspos(N, activate(Z))),
                                    pi(X) -> 2ndspos(X, from(0())),
                             plus(0(), Y) -> Y,
                            plus(s(X), Y) -> s(plus(X, Y)),
                            times(0(), Y) -> 0(),
                           times(s(X), Y) -> plus(Y, times(X, Y)),
                                square(X) -> times(X, X)}
     SPSC:
      Simple Projection:
       pi(2ndsneg#) = 0, pi(2ndspos#) = 0
      Strict:
       {          2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))),
        2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)),
                  2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z)))}
      EDG:
       {(2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)), 2ndsneg#(s(N), cons(X, Z)) -> 2ndsneg#(s(N), cons2(X, activate(Z))))
        (2ndspos#(s(N), cons(X, Z)) -> 2ndspos#(s(N), cons2(X, activate(Z))), 2ndspos#(s(N), cons2(X, cons(Y, Z))) -> 2ndsneg#(N, activate(Z)))}
       SCCS:
        
        Qed