WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(X1,X2)
            activate(n__from(X)) -> from(X)
            activate(n__fst(X1,X2)) -> fst(X1,X2)
            activate(n__len(X)) -> len(X)
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            add(s(X),Y) -> s(n__add(activate(X),Y))
            from(X) -> cons(X,n__from(s(X)))
            from(X) -> n__from(X)
            fst(X1,X2) -> n__fst(X1,X2)
            fst(0(),Z) -> nil()
            fst(s(X),cons(Y,Z)) -> cons(Y,n__fst(activate(X),activate(Z)))
            len(X) -> n__len(X)
            len(cons(X,Z)) -> s(n__len(activate(Z)))
            len(nil()) -> 0()
        - Signature:
            {activate/1,add/2,from/1,fst/2,len/1} / {0/0,cons/2,n__add/2,n__from/1,n__fst/2,n__len/1,nil/0,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,from,fst,len} and constructors {0,cons
            ,n__add,n__from,n__fst,n__len,nil,s}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = NoRestrict, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(cons) = {2},
          uargs(n__add) = {1},
          uargs(n__fst) = {1,2},
          uargs(n__len) = {1},
          uargs(s) = {1}
        
        Following symbols are considered usable:
          {activate,add,from,fst,len}
        TcT has computed the following interpretation:
                 p(0) = 1              
          p(activate) = 1 + 2*x1       
               p(add) = 3 + 2*x1 + x2  
              p(cons) = x2             
              p(from) = 2              
               p(fst) = 3 + 2*x1 + 2*x2
               p(len) = 7 + 2*x1       
            p(n__add) = 2 + x1 + x2    
           p(n__from) = 1              
            p(n__fst) = 2 + x1 + x2    
            p(n__len) = 4 + x1         
               p(nil) = 1              
                 p(s) = 1 + x1         
        
        Following rules are strictly oriented:
                    activate(X) = 1 + 2*X                                
                                > X                                      
                                = X                                      
        
        activate(n__add(X1,X2)) = 5 + 2*X1 + 2*X2                        
                                > 3 + 2*X1 + X2                          
                                = add(X1,X2)                             
        
           activate(n__from(X)) = 3                                      
                                > 2                                      
                                = from(X)                                
        
        activate(n__fst(X1,X2)) = 5 + 2*X1 + 2*X2                        
                                > 3 + 2*X1 + 2*X2                        
                                = fst(X1,X2)                             
        
            activate(n__len(X)) = 9 + 2*X                                
                                > 7 + 2*X                                
                                = len(X)                                 
        
                     add(X1,X2) = 3 + 2*X1 + X2                          
                                > 2 + X1 + X2                            
                                = n__add(X1,X2)                          
        
                     add(0(),X) = 5 + X                                  
                                > X                                      
                                = X                                      
        
                    add(s(X),Y) = 5 + 2*X + Y                            
                                > 4 + 2*X + Y                            
                                = s(n__add(activate(X),Y))               
        
                        from(X) = 2                                      
                                > 1                                      
                                = cons(X,n__from(s(X)))                  
        
                        from(X) = 2                                      
                                > 1                                      
                                = n__from(X)                             
        
                     fst(X1,X2) = 3 + 2*X1 + 2*X2                        
                                > 2 + X1 + X2                            
                                = n__fst(X1,X2)                          
        
                     fst(0(),Z) = 5 + 2*Z                                
                                > 1                                      
                                = nil()                                  
        
            fst(s(X),cons(Y,Z)) = 5 + 2*X + 2*Z                          
                                > 4 + 2*X + 2*Z                          
                                = cons(Y,n__fst(activate(X),activate(Z)))
        
                         len(X) = 7 + 2*X                                
                                > 4 + X                                  
                                = n__len(X)                              
        
                 len(cons(X,Z)) = 7 + 2*Z                                
                                > 6 + 2*Z                                
                                = s(n__len(activate(Z)))                 
        
                     len(nil()) = 9                                      
                                > 1                                      
                                = 0()                                    
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))