WORST_CASE(?,O(n^1))
* Step 1: InnermostRuleRemoval WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            add(s(X),Y) -> s(n__add(activate(X),Y))
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            dbl(s(X)) -> s(n__s(n__dbl(activate(X))))
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            first(s(X),cons(Y,Z)) -> cons(Y,n__first(activate(X),activate(Z)))
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
            sqr(s(X)) -> s(n__add(n__sqr(activate(X)),n__dbl(activate(X))))
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        InnermostRuleRemoval
    + Details:
        Arguments of following rules are not normal-forms.
          add(s(X),Y) -> s(n__add(activate(X),Y))
          dbl(s(X)) -> s(n__s(n__dbl(activate(X))))
          first(s(X),cons(Y,Z)) -> cons(Y,n__first(activate(X),activate(Z)))
          sqr(s(X)) -> s(n__add(n__sqr(activate(X)),n__dbl(activate(X))))
        All above mentioned rules can be savely removed.
* Step 2: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [0]                  
            p(activate) = [2] x1 + [0]         
                 p(add) = [1] x1 + [1] x2 + [0]
                p(cons) = [1] x1 + [1] x2 + [0]
                 p(dbl) = [1] x1 + [0]         
               p(first) = [1] x1 + [1] x2 + [3]
              p(n__add) = [1] x1 + [1] x2 + [0]
              p(n__dbl) = [1] x1 + [0]         
            p(n__first) = [1] x1 + [1] x2 + [0]
                p(n__s) = [0]                  
              p(n__sqr) = [1] x1 + [0]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [0]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [0]                  
                 p(sqr) = [1] x1 + [0]         
               p(terms) = [1] x1 + [1]         
          
          Following rules are strictly oriented:
          first(X1,X2) = [1] X1 + [1] X2 + [3]                
                       > [1] X1 + [1] X2 + [0]                
                       = n__first(X1,X2)                      
          
          first(0(),X) = [1] X + [3]                          
                       > [0]                                  
                       = nil()                                
          
              terms(N) = [1] N + [1]                          
                       > [1] N + [0]                          
                       = cons(recip(sqr(N)),n__terms(n__s(N)))
          
              terms(X) = [1] X + [1]                          
                       > [1] X + [0]                          
                       = n__terms(X)                          
          
          
          Following rules are (at-least) weakly oriented:
                        activate(X) =  [2] X + [0]                     
                                    >= [1] X + [0]                     
                                    =  X                               
          
            activate(n__add(X1,X2)) =  [2] X1 + [2] X2 + [0]           
                                    >= [2] X1 + [2] X2 + [0]           
                                    =  add(activate(X1),activate(X2))  
          
                activate(n__dbl(X)) =  [2] X + [0]                     
                                    >= [2] X + [0]                     
                                    =  dbl(activate(X))                
          
          activate(n__first(X1,X2)) =  [2] X1 + [2] X2 + [0]           
                                    >= [2] X1 + [2] X2 + [3]           
                                    =  first(activate(X1),activate(X2))
          
                  activate(n__s(X)) =  [0]                             
                                    >= [0]                             
                                    =  s(X)                            
          
                activate(n__sqr(X)) =  [2] X + [0]                     
                                    >= [2] X + [0]                     
                                    =  sqr(activate(X))                
          
              activate(n__terms(X)) =  [2] X + [0]                     
                                    >= [2] X + [1]                     
                                    =  terms(activate(X))              
          
                         add(X1,X2) =  [1] X1 + [1] X2 + [0]           
                                    >= [1] X1 + [1] X2 + [0]           
                                    =  n__add(X1,X2)                   
          
                         add(0(),X) =  [1] X + [0]                     
                                    >= [1] X + [0]                     
                                    =  X                               
          
                             dbl(X) =  [1] X + [0]                     
                                    >= [1] X + [0]                     
                                    =  n__dbl(X)                       
          
                           dbl(0()) =  [0]                             
                                    >= [0]                             
                                    =  0()                             
          
                               s(X) =  [0]                             
                                    >= [0]                             
                                    =  n__s(X)                         
          
                             sqr(X) =  [1] X + [0]                     
                                    >= [1] X + [0]                     
                                    =  n__sqr(X)                       
          
                           sqr(0()) =  [0]                             
                                    >= [0]                             
                                    =  0()                             
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 3: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
        - Weak TRS:
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [2]                  
            p(activate) = [2] x1 + [0]         
                 p(add) = [1] x1 + [1] x2 + [0]
                p(cons) = [1] x1 + [3]         
                 p(dbl) = [1] x1 + [2]         
               p(first) = [1] x1 + [1] x2 + [2]
              p(n__add) = [1] x1 + [1] x2 + [2]
              p(n__dbl) = [1] x1 + [0]         
            p(n__first) = [1] x1 + [1] x2 + [1]
                p(n__s) = [4]                  
              p(n__sqr) = [1] x1 + [1]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [4]                  
               p(recip) = [1] x1 + [1]         
                   p(s) = [0]                  
                 p(sqr) = [1] x1 + [1]         
               p(terms) = [1] x1 + [6]         
          
          Following rules are strictly oriented:
          activate(n__add(X1,X2)) = [2] X1 + [2] X2 + [4]         
                                  > [2] X1 + [2] X2 + [0]         
                                  = add(activate(X1),activate(X2))
          
                activate(n__s(X)) = [8]                           
                                  > [0]                           
                                  = s(X)                          
          
              activate(n__sqr(X)) = [2] X + [2]                   
                                  > [2] X + [1]                   
                                  = sqr(activate(X))              
          
                       add(0(),X) = [1] X + [2]                   
                                  > [1] X + [0]                   
                                  = X                             
          
                           dbl(X) = [1] X + [2]                   
                                  > [1] X + [0]                   
                                  = n__dbl(X)                     
          
                         dbl(0()) = [4]                           
                                  > [2]                           
                                  = 0()                           
          
                         sqr(0()) = [3]                           
                                  > [2]                           
                                  = 0()                           
          
          
          Following rules are (at-least) weakly oriented:
                        activate(X) =  [2] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
                activate(n__dbl(X)) =  [2] X + [0]                          
                                    >= [2] X + [2]                          
                                    =  dbl(activate(X))                     
          
          activate(n__first(X1,X2)) =  [2] X1 + [2] X2 + [2]                
                                    >= [2] X1 + [2] X2 + [2]                
                                    =  first(activate(X1),activate(X2))     
          
              activate(n__terms(X)) =  [2] X + [0]                          
                                    >= [2] X + [6]                          
                                    =  terms(activate(X))                   
          
                         add(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                    >= [1] X1 + [1] X2 + [2]                
                                    =  n__add(X1,X2)                        
          
                       first(X1,X2) =  [1] X1 + [1] X2 + [2]                
                                    >= [1] X1 + [1] X2 + [1]                
                                    =  n__first(X1,X2)                      
          
                       first(0(),X) =  [1] X + [4]                          
                                    >= [4]                                  
                                    =  nil()                                
          
                               s(X) =  [0]                                  
                                    >= [4]                                  
                                    =  n__s(X)                              
          
                             sqr(X) =  [1] X + [1]                          
                                    >= [1] X + [1]                          
                                    =  n__sqr(X)                            
          
                           terms(N) =  [1] N + [6]                          
                                    >= [1] N + [5]                          
                                    =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                           terms(X) =  [1] X + [6]                          
                                    >= [1] X + [0]                          
                                    =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 4: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
        - Weak TRS:
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [0]                  
            p(activate) = [1] x1 + [2]         
                 p(add) = [1] x1 + [1] x2 + [0]
                p(cons) = [1] x1 + [0]         
                 p(dbl) = [1] x1 + [1]         
               p(first) = [1] x1 + [1] x2 + [2]
              p(n__add) = [1] x1 + [1] x2 + [5]
              p(n__dbl) = [1] x1 + [0]         
            p(n__first) = [1] x1 + [1] x2 + [0]
                p(n__s) = [5]                  
              p(n__sqr) = [1] x1 + [0]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [1]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [7]                  
                 p(sqr) = [1] x1 + [0]         
               p(terms) = [1] x1 + [0]         
          
          Following rules are strictly oriented:
          activate(X) = [1] X + [2]
                      > [1] X + [0]
                      = X          
          
                 s(X) = [7]        
                      > [5]        
                      = n__s(X)    
          
          
          Following rules are (at-least) weakly oriented:
            activate(n__add(X1,X2)) =  [1] X1 + [1] X2 + [7]                
                                    >= [1] X1 + [1] X2 + [4]                
                                    =  add(activate(X1),activate(X2))       
          
                activate(n__dbl(X)) =  [1] X + [2]                          
                                    >= [1] X + [3]                          
                                    =  dbl(activate(X))                     
          
          activate(n__first(X1,X2)) =  [1] X1 + [1] X2 + [2]                
                                    >= [1] X1 + [1] X2 + [6]                
                                    =  first(activate(X1),activate(X2))     
          
                  activate(n__s(X)) =  [7]                                  
                                    >= [7]                                  
                                    =  s(X)                                 
          
                activate(n__sqr(X)) =  [1] X + [2]                          
                                    >= [1] X + [2]                          
                                    =  sqr(activate(X))                     
          
              activate(n__terms(X)) =  [1] X + [2]                          
                                    >= [1] X + [2]                          
                                    =  terms(activate(X))                   
          
                         add(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                    >= [1] X1 + [1] X2 + [5]                
                                    =  n__add(X1,X2)                        
          
                         add(0(),X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
                             dbl(X) =  [1] X + [1]                          
                                    >= [1] X + [0]                          
                                    =  n__dbl(X)                            
          
                           dbl(0()) =  [1]                                  
                                    >= [0]                                  
                                    =  0()                                  
          
                       first(X1,X2) =  [1] X1 + [1] X2 + [2]                
                                    >= [1] X1 + [1] X2 + [0]                
                                    =  n__first(X1,X2)                      
          
                       first(0(),X) =  [1] X + [2]                          
                                    >= [1]                                  
                                    =  nil()                                
          
                             sqr(X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__sqr(X)                            
          
                           sqr(0()) =  [0]                                  
                                    >= [0]                                  
                                    =  0()                                  
          
                           terms(N) =  [1] N + [0]                          
                                    >= [1] N + [0]                          
                                    =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                           terms(X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 5: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            sqr(X) -> n__sqr(X)
        - Weak TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [0]                  
            p(activate) = [4] x1 + [0]         
                 p(add) = [1] x1 + [1] x2 + [4]
                p(cons) = [1] x1 + [0]         
                 p(dbl) = [1] x1 + [0]         
               p(first) = [1] x1 + [1] x2 + [4]
              p(n__add) = [1] x1 + [1] x2 + [2]
              p(n__dbl) = [1] x1 + [0]         
            p(n__first) = [1] x1 + [1] x2 + [0]
                p(n__s) = [1]                  
              p(n__sqr) = [1] x1 + [2]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [1]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [4]                  
                 p(sqr) = [1] x1 + [1]         
               p(terms) = [1] x1 + [4]         
          
          Following rules are strictly oriented:
          add(X1,X2) = [1] X1 + [1] X2 + [4]
                     > [1] X1 + [1] X2 + [2]
                     = n__add(X1,X2)        
          
          
          Following rules are (at-least) weakly oriented:
                        activate(X) =  [4] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
            activate(n__add(X1,X2)) =  [4] X1 + [4] X2 + [8]                
                                    >= [4] X1 + [4] X2 + [4]                
                                    =  add(activate(X1),activate(X2))       
          
                activate(n__dbl(X)) =  [4] X + [0]                          
                                    >= [4] X + [0]                          
                                    =  dbl(activate(X))                     
          
          activate(n__first(X1,X2)) =  [4] X1 + [4] X2 + [0]                
                                    >= [4] X1 + [4] X2 + [4]                
                                    =  first(activate(X1),activate(X2))     
          
                  activate(n__s(X)) =  [4]                                  
                                    >= [4]                                  
                                    =  s(X)                                 
          
                activate(n__sqr(X)) =  [4] X + [8]                          
                                    >= [4] X + [1]                          
                                    =  sqr(activate(X))                     
          
              activate(n__terms(X)) =  [4] X + [0]                          
                                    >= [4] X + [4]                          
                                    =  terms(activate(X))                   
          
                         add(0(),X) =  [1] X + [4]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
                             dbl(X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__dbl(X)                            
          
                           dbl(0()) =  [0]                                  
                                    >= [0]                                  
                                    =  0()                                  
          
                       first(X1,X2) =  [1] X1 + [1] X2 + [4]                
                                    >= [1] X1 + [1] X2 + [0]                
                                    =  n__first(X1,X2)                      
          
                       first(0(),X) =  [1] X + [4]                          
                                    >= [1]                                  
                                    =  nil()                                
          
                               s(X) =  [4]                                  
                                    >= [1]                                  
                                    =  n__s(X)                              
          
                             sqr(X) =  [1] X + [1]                          
                                    >= [1] X + [2]                          
                                    =  n__sqr(X)                            
          
                           sqr(0()) =  [1]                                  
                                    >= [0]                                  
                                    =  0()                                  
          
                           terms(N) =  [1] N + [4]                          
                                    >= [1] N + [1]                          
                                    =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                           terms(X) =  [1] X + [4]                          
                                    >= [1] X + [0]                          
                                    =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 6: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__terms(X)) -> terms(activate(X))
            sqr(X) -> n__sqr(X)
        - Weak TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [3]                  
            p(activate) = [4] x1 + [0]         
                 p(add) = [1] x1 + [1] x2 + [0]
                p(cons) = [1] x1 + [3]         
                 p(dbl) = [1] x1 + [0]         
               p(first) = [1] x1 + [1] x2 + [0]
              p(n__add) = [1] x1 + [1] x2 + [0]
              p(n__dbl) = [1] x1 + [0]         
            p(n__first) = [1] x1 + [1] x2 + [0]
                p(n__s) = [1] x1 + [0]         
              p(n__sqr) = [1] x1 + [1]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [3]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [4] x1 + [0]         
                 p(sqr) = [1] x1 + [4]         
               p(terms) = [1] x1 + [7]         
          
          Following rules are strictly oriented:
          sqr(X) = [1] X + [4]
                 > [1] X + [1]
                 = n__sqr(X)  
          
          
          Following rules are (at-least) weakly oriented:
                        activate(X) =  [4] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
            activate(n__add(X1,X2)) =  [4] X1 + [4] X2 + [0]                
                                    >= [4] X1 + [4] X2 + [0]                
                                    =  add(activate(X1),activate(X2))       
          
                activate(n__dbl(X)) =  [4] X + [0]                          
                                    >= [4] X + [0]                          
                                    =  dbl(activate(X))                     
          
          activate(n__first(X1,X2)) =  [4] X1 + [4] X2 + [0]                
                                    >= [4] X1 + [4] X2 + [0]                
                                    =  first(activate(X1),activate(X2))     
          
                  activate(n__s(X)) =  [4] X + [0]                          
                                    >= [4] X + [0]                          
                                    =  s(X)                                 
          
                activate(n__sqr(X)) =  [4] X + [4]                          
                                    >= [4] X + [4]                          
                                    =  sqr(activate(X))                     
          
              activate(n__terms(X)) =  [4] X + [0]                          
                                    >= [4] X + [7]                          
                                    =  terms(activate(X))                   
          
                         add(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                    >= [1] X1 + [1] X2 + [0]                
                                    =  n__add(X1,X2)                        
          
                         add(0(),X) =  [1] X + [3]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
                             dbl(X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__dbl(X)                            
          
                           dbl(0()) =  [3]                                  
                                    >= [3]                                  
                                    =  0()                                  
          
                       first(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                    >= [1] X1 + [1] X2 + [0]                
                                    =  n__first(X1,X2)                      
          
                       first(0(),X) =  [1] X + [3]                          
                                    >= [3]                                  
                                    =  nil()                                
          
                               s(X) =  [4] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__s(X)                              
          
                           sqr(0()) =  [7]                                  
                                    >= [3]                                  
                                    =  0()                                  
          
                           terms(N) =  [1] N + [7]                          
                                    >= [1] N + [7]                          
                                    =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                           terms(X) =  [1] X + [7]                          
                                    >= [1] X + [0]                          
                                    =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 7: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__terms(X)) -> terms(activate(X))
        - Weak TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [2]                  
            p(activate) = [4] x1 + [1]         
                 p(add) = [1] x1 + [1] x2 + [4]
                p(cons) = [1] x1 + [1] x2 + [0]
                 p(dbl) = [1] x1 + [3]         
               p(first) = [1] x1 + [1] x2 + [0]
              p(n__add) = [1] x1 + [1] x2 + [2]
              p(n__dbl) = [1] x1 + [3]         
            p(n__first) = [1] x1 + [1] x2 + [0]
                p(n__s) = [2]                  
              p(n__sqr) = [1] x1 + [0]         
            p(n__terms) = [1] x1 + [3]         
                 p(nil) = [2]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [2]                  
                 p(sqr) = [1] x1 + [0]         
               p(terms) = [1] x1 + [5]         
          
          Following rules are strictly oriented:
            activate(n__dbl(X)) = [4] X + [13]      
                                > [4] X + [4]       
                                = dbl(activate(X))  
          
          activate(n__terms(X)) = [4] X + [13]      
                                > [4] X + [6]       
                                = terms(activate(X))
          
          
          Following rules are (at-least) weakly oriented:
                        activate(X) =  [4] X + [1]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
            activate(n__add(X1,X2)) =  [4] X1 + [4] X2 + [9]                
                                    >= [4] X1 + [4] X2 + [6]                
                                    =  add(activate(X1),activate(X2))       
          
          activate(n__first(X1,X2)) =  [4] X1 + [4] X2 + [1]                
                                    >= [4] X1 + [4] X2 + [2]                
                                    =  first(activate(X1),activate(X2))     
          
                  activate(n__s(X)) =  [9]                                  
                                    >= [2]                                  
                                    =  s(X)                                 
          
                activate(n__sqr(X)) =  [4] X + [1]                          
                                    >= [4] X + [1]                          
                                    =  sqr(activate(X))                     
          
                         add(X1,X2) =  [1] X1 + [1] X2 + [4]                
                                    >= [1] X1 + [1] X2 + [2]                
                                    =  n__add(X1,X2)                        
          
                         add(0(),X) =  [1] X + [6]                          
                                    >= [1] X + [0]                          
                                    =  X                                    
          
                             dbl(X) =  [1] X + [3]                          
                                    >= [1] X + [3]                          
                                    =  n__dbl(X)                            
          
                           dbl(0()) =  [5]                                  
                                    >= [2]                                  
                                    =  0()                                  
          
                       first(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                    >= [1] X1 + [1] X2 + [0]                
                                    =  n__first(X1,X2)                      
          
                       first(0(),X) =  [1] X + [2]                          
                                    >= [2]                                  
                                    =  nil()                                
          
                               s(X) =  [2]                                  
                                    >= [2]                                  
                                    =  n__s(X)                              
          
                             sqr(X) =  [1] X + [0]                          
                                    >= [1] X + [0]                          
                                    =  n__sqr(X)                            
          
                           sqr(0()) =  [2]                                  
                                    >= [2]                                  
                                    =  0()                                  
          
                           terms(N) =  [1] N + [5]                          
                                    >= [1] N + [5]                          
                                    =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                           terms(X) =  [1] X + [5]                          
                                    >= [1] X + [3]                          
                                    =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 8: WeightGap WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
        - Weak TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    + Details:
        The weightgap principle applies using the following nonconstant growth matrix-interpretation:
          We apply a matrix interpretation of kind constructor based matrix interpretation:
          The following argument positions are considered usable:
            uargs(add) = {1,2},
            uargs(cons) = {1},
            uargs(dbl) = {1},
            uargs(first) = {1,2},
            uargs(recip) = {1},
            uargs(sqr) = {1},
            uargs(terms) = {1}
          
          Following symbols are considered usable:
            all
          TcT has computed the following interpretation:
                   p(0) = [0]                  
            p(activate) = [2] x1 + [0]         
                 p(add) = [1] x1 + [1] x2 + [0]
                p(cons) = [1] x1 + [1] x2 + [0]
                 p(dbl) = [1] x1 + [6]         
               p(first) = [1] x1 + [1] x2 + [7]
              p(n__add) = [1] x1 + [1] x2 + [0]
              p(n__dbl) = [1] x1 + [3]         
            p(n__first) = [1] x1 + [1] x2 + [5]
                p(n__s) = [0]                  
              p(n__sqr) = [1] x1 + [0]         
            p(n__terms) = [1] x1 + [0]         
                 p(nil) = [7]                  
               p(recip) = [1] x1 + [0]         
                   p(s) = [0]                  
                 p(sqr) = [1] x1 + [0]         
               p(terms) = [1] x1 + [0]         
          
          Following rules are strictly oriented:
          activate(n__first(X1,X2)) = [2] X1 + [2] X2 + [10]          
                                    > [2] X1 + [2] X2 + [7]           
                                    = first(activate(X1),activate(X2))
          
          
          Following rules are (at-least) weakly oriented:
                      activate(X) =  [2] X + [0]                          
                                  >= [1] X + [0]                          
                                  =  X                                    
          
          activate(n__add(X1,X2)) =  [2] X1 + [2] X2 + [0]                
                                  >= [2] X1 + [2] X2 + [0]                
                                  =  add(activate(X1),activate(X2))       
          
              activate(n__dbl(X)) =  [2] X + [6]                          
                                  >= [2] X + [6]                          
                                  =  dbl(activate(X))                     
          
                activate(n__s(X)) =  [0]                                  
                                  >= [0]                                  
                                  =  s(X)                                 
          
              activate(n__sqr(X)) =  [2] X + [0]                          
                                  >= [2] X + [0]                          
                                  =  sqr(activate(X))                     
          
            activate(n__terms(X)) =  [2] X + [0]                          
                                  >= [2] X + [0]                          
                                  =  terms(activate(X))                   
          
                       add(X1,X2) =  [1] X1 + [1] X2 + [0]                
                                  >= [1] X1 + [1] X2 + [0]                
                                  =  n__add(X1,X2)                        
          
                       add(0(),X) =  [1] X + [0]                          
                                  >= [1] X + [0]                          
                                  =  X                                    
          
                           dbl(X) =  [1] X + [6]                          
                                  >= [1] X + [3]                          
                                  =  n__dbl(X)                            
          
                         dbl(0()) =  [6]                                  
                                  >= [0]                                  
                                  =  0()                                  
          
                     first(X1,X2) =  [1] X1 + [1] X2 + [7]                
                                  >= [1] X1 + [1] X2 + [5]                
                                  =  n__first(X1,X2)                      
          
                     first(0(),X) =  [1] X + [7]                          
                                  >= [7]                                  
                                  =  nil()                                
          
                             s(X) =  [0]                                  
                                  >= [0]                                  
                                  =  n__s(X)                              
          
                           sqr(X) =  [1] X + [0]                          
                                  >= [1] X + [0]                          
                                  =  n__sqr(X)                            
          
                         sqr(0()) =  [0]                                  
                                  >= [0]                                  
                                  =  0()                                  
          
                         terms(N) =  [1] N + [0]                          
                                  >= [1] N + [0]                          
                                  =  cons(recip(sqr(N)),n__terms(n__s(N)))
          
                         terms(X) =  [1] X + [0]                          
                                  >= [1] X + [0]                          
                                  =  n__terms(X)                          
          
        Further, it can be verified that all rules not oriented are covered by the weightgap condition.
* Step 9: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            activate(X) -> X
            activate(n__add(X1,X2)) -> add(activate(X1),activate(X2))
            activate(n__dbl(X)) -> dbl(activate(X))
            activate(n__first(X1,X2)) -> first(activate(X1),activate(X2))
            activate(n__s(X)) -> s(X)
            activate(n__sqr(X)) -> sqr(activate(X))
            activate(n__terms(X)) -> terms(activate(X))
            add(X1,X2) -> n__add(X1,X2)
            add(0(),X) -> X
            dbl(X) -> n__dbl(X)
            dbl(0()) -> 0()
            first(X1,X2) -> n__first(X1,X2)
            first(0(),X) -> nil()
            s(X) -> n__s(X)
            sqr(X) -> n__sqr(X)
            sqr(0()) -> 0()
            terms(N) -> cons(recip(sqr(N)),n__terms(n__s(N)))
            terms(X) -> n__terms(X)
        - Signature:
            {activate/1,add/2,dbl/1,first/2,s/1,sqr/1,terms/1} / {0/0,cons/2,n__add/2,n__dbl/1,n__first/2,n__s/1
            ,n__sqr/1,n__terms/1,nil/0,recip/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {activate,add,dbl,first,s,sqr,terms} and constructors {0
            ,cons,n__add,n__dbl,n__first,n__s,n__sqr,n__terms,nil,recip}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))