*** 1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        sqr(x) -> *(x,x)
        sum(0()) -> 0()
        sum(s(x)) -> +(*(s(x),s(x)),sum(x))
        sum(s(x)) -> +(sqr(s(x)),sum(x))
      Weak DP Rules:
        
      Weak TRS Rules:
        
      Signature:
        {sqr/1,sum/1} / {*/2,+/2,0/0,s/1}
      Obligation:
        Full
        basic terms: {sqr,sum}/{*,+,0,s}
    Applied Processor:
      WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    Proof:
      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(+) = {1,2}
        
        Following symbols are considered usable:
          {}
        TcT has computed the following interpretation:
            p(*) = [8]                  
            p(+) = [1] x1 + [1] x2 + [2]
            p(0) = [3]                  
            p(s) = [1] x1 + [5]         
          p(sqr) = [8]                  
          p(sum) = [3] x1 + [6]         
        
        Following rules are strictly oriented:
         sum(0()) = [15]                  
                  > [3]                   
                  = 0()                   
        
        sum(s(x)) = [3] x + [21]          
                  > [3] x + [16]          
                  = +(*(s(x),s(x)),sum(x))
        
        sum(s(x)) = [3] x + [21]          
                  > [3] x + [16]          
                  = +(sqr(s(x)),sum(x))   
        
        
        Following rules are (at-least) weakly oriented:
        sqr(x) =  [8]   
               >= [8]   
               =  *(x,x)
        
      Further, it can be verified that all rules not oriented are covered by the weightgap condition.
*** 1.1 Progress [(O(1),O(n^1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        sqr(x) -> *(x,x)
      Weak DP Rules:
        
      Weak TRS Rules:
        sum(0()) -> 0()
        sum(s(x)) -> +(*(s(x),s(x)),sum(x))
        sum(s(x)) -> +(sqr(s(x)),sum(x))
      Signature:
        {sqr/1,sum/1} / {*/2,+/2,0/0,s/1}
      Obligation:
        Full
        basic terms: {sqr,sum}/{*,+,0,s}
    Applied Processor:
      WeightGap {wgDimension = 1, wgDegree = 1, wgKind = Algebraic, wgUArgs = UArgs, wgOn = WgOnAny}
    Proof:
      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(+) = {1,2}
        
        Following symbols are considered usable:
          {}
        TcT has computed the following interpretation:
            p(*) = [0]                  
            p(+) = [1] x1 + [1] x2 + [0]
            p(0) = [0]                  
            p(s) = [1] x1 + [1]         
          p(sqr) = [1]                  
          p(sum) = [1] x1 + [0]         
        
        Following rules are strictly oriented:
        sqr(x) = [1]   
               > [0]   
               = *(x,x)
        
        
        Following rules are (at-least) weakly oriented:
         sum(0()) =  [0]                   
                  >= [0]                   
                  =  0()                   
        
        sum(s(x)) =  [1] x + [1]           
                  >= [1] x + [0]           
                  =  +(*(s(x),s(x)),sum(x))
        
        sum(s(x)) =  [1] x + [1]           
                  >= [1] x + [1]           
                  =  +(sqr(s(x)),sum(x))   
        
      Further, it can be verified that all rules not oriented are covered by the weightgap condition.
*** 1.1.1 Progress [(O(1),O(1))]  ***
    Considered Problem:
      Strict DP Rules:
        
      Strict TRS Rules:
        
      Weak DP Rules:
        
      Weak TRS Rules:
        sqr(x) -> *(x,x)
        sum(0()) -> 0()
        sum(s(x)) -> +(*(s(x),s(x)),sum(x))
        sum(s(x)) -> +(sqr(s(x)),sum(x))
      Signature:
        {sqr/1,sum/1} / {*/2,+/2,0/0,s/1}
      Obligation:
        Full
        basic terms: {sqr,sum}/{*,+,0,s}
    Applied Processor:
      EmptyProcessor
    Proof:
      The problem is already closed. The intended complexity is O(1).