WORST_CASE(?,O(n^1))
* Step 1: LocalSizeboundsProc WORST_CASE(?,O(n^1))
    + Considered Problem:
        Rules:
          0. start(A) -> a(A)      [A >= 1]  (1,1)
          1. start(A) -> a(100)    [A = 100] (1,1)
          2. a(A)     -> a(-1 + A) [A >= 1]  (?,1)
        Signature:
          {(a,1);(start,1)}
        Flow Graph:
          [0->{2},1->{2},2->{2}]
        
    + Applied Processor:
        LocalSizeboundsProc
    + Details:
        LocalSizebounds generated; rvgraph
          (<0,0,A>,     A,   .= 0) 
          (<1,0,A>,   100, .= 100) 
          (<2,0,A>, 1 + A,   .+ 1) 
* Step 2: SizeboundsProc WORST_CASE(?,O(n^1))
    + Considered Problem:
        Rules:
          0. start(A) -> a(A)      [A >= 1]  (1,1)
          1. start(A) -> a(100)    [A = 100] (1,1)
          2. a(A)     -> a(-1 + A) [A >= 1]  (?,1)
        Signature:
          {(a,1);(start,1)}
        Flow Graph:
          [0->{2},1->{2},2->{2}]
        Sizebounds:
          (<0,0,A>, ?) 
          (<1,0,A>, ?) 
          (<2,0,A>, ?) 
    + Applied Processor:
        SizeboundsProc
    + Details:
        Sizebounds computed:
          (<0,0,A>,   A) 
          (<1,0,A>, 100) 
          (<2,0,A>,   ?) 
* Step 3: PolyRank WORST_CASE(?,O(n^1))
    + Considered Problem:
        Rules:
          0. start(A) -> a(A)      [A >= 1]  (1,1)
          1. start(A) -> a(100)    [A = 100] (1,1)
          2. a(A)     -> a(-1 + A) [A >= 1]  (?,1)
        Signature:
          {(a,1);(start,1)}
        Flow Graph:
          [0->{2},1->{2},2->{2}]
        Sizebounds:
          (<0,0,A>,   A) 
          (<1,0,A>, 100) 
          (<2,0,A>,   ?) 
    + Applied Processor:
        PolyRank {useFarkas = True, withSizebounds = [], shape = Linear}
    + Details:
        We apply a polynomial interpretation of shape linear:
              p(a) = x1
          p(start) = x1
        
        The following rules are strictly oriented:
        [A >= 1] ==>          
            a(A)   = A        
                   > -1 + A   
                   = a(-1 + A)
        
        
        The following rules are weakly oriented:
          [A >= 1] ==>       
          start(A)   = A     
                    >= A     
                     = a(A)  
        
         [A = 100] ==>       
          start(A)   = A     
                    >= 100   
                     = a(100)
        
        
* Step 4: KnowledgePropagation WORST_CASE(?,O(n^1))
    + Considered Problem:
        Rules:
          0. start(A) -> a(A)      [A >= 1]  (1,1)
          1. start(A) -> a(100)    [A = 100] (1,1)
          2. a(A)     -> a(-1 + A) [A >= 1]  (A,1)
        Signature:
          {(a,1);(start,1)}
        Flow Graph:
          [0->{2},1->{2},2->{2}]
        Sizebounds:
          (<0,0,A>,   A) 
          (<1,0,A>, 100) 
          (<2,0,A>,   ?) 
    + Applied Processor:
        KnowledgePropagation
    + Details:
        The problem is already solved.

WORST_CASE(?,O(n^1))