YES

Problem:
 fst(0(),Z) -> nil()
 fst(s(X),cons(Y,Z)) -> cons(Y,n__fst(activate(X),activate(Z)))
 from(X) -> cons(X,n__from(n__s(X)))
 add(0(),X) -> X
 add(s(X),Y) -> s(n__add(activate(X),Y))
 len(nil()) -> 0()
 len(cons(X,Z)) -> s(n__len(activate(Z)))
 fst(X1,X2) -> n__fst(X1,X2)
 from(X) -> n__from(X)
 s(X) -> n__s(X)
 add(X1,X2) -> n__add(X1,X2)
 len(X) -> n__len(X)
 activate(n__fst(X1,X2)) -> fst(activate(X1),activate(X2))
 activate(n__from(X)) -> from(activate(X))
 activate(n__s(X)) -> s(X)
 activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
 activate(n__len(X)) -> len(activate(X))
 activate(X) -> X

Proof:
 WPO Processor:
  algebra: Max
  weight function:
   w0 = 0
   w(n__fst) = 1
   w(n__len) = w(len) = w(n__add) = w(add) = w(n__from) = w(n__s) = w(
   from) = w(activate) = w(cons) = w(s) = w(nil) = w(fst) = w(0) = 0
  status function:
   st(n__add) = st(add) = [1, 0]
   st(n__len) = st(len) = st(n__from) = st(n__s) = st(from) = [0]
   st(n__fst) = [0, 1]
   st(activate) = [0]
   st(cons) = [0, 1]
   st(s) = [0]
   st(nil) = []
   st(fst) = [0, 1]
   st(0) = []
  subterm penalty function:
   sp(n__add, 0) = sp(add, 0) = 2
   sp(n__len, 0) = sp(len, 0) = sp(n__fst, 1) = sp(n__fst, 0) = sp(fst, 1) = sp(
   fst, 0) = 1
   sp(n__add, 1) = sp(add, 1) = sp(n__from, 0) = sp(n__s, 0) = sp(from, 0) = sp(
   activate, 0) = sp(cons, 1) = sp(cons, 0) = sp(s, 0) = 0
  precedence:
   activate > len ~ add > from ~ s ~ fst > n__len ~ n__add ~ n__from ~ 
   n__s ~ n__fst ~ cons ~ nil ~ 0
  problem:
   
  Qed