WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            divp(x,y) -> =(rem(x,y),0())
            prime(0()) -> false()
            prime(s(0())) -> false()
            prime(s(s(x))) -> prime1(s(s(x)),s(x))
            prime1(x,0()) -> false()
            prime1(x,s(0())) -> true()
            prime1(x,s(s(y))) -> and(not(divp(s(s(y)),x)),prime1(x,s(y)))
        - Signature:
            {divp/2,prime/1,prime1/2} / {0/0,=/2,and/2,false/0,not/1,rem/2,s/1,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {divp,prime,prime1} and constructors {0,=,and,false,not
            ,rem,s,true}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = UArgs, urules = URules, selector = Nothing}
    + Details:
        We apply a matrix interpretation of kind constructor based matrix interpretation:
        The following argument positions are considered usable:
          uargs(and) = {1,2},
          uargs(not) = {1}
        
        Following symbols are considered usable:
          {divp,prime,prime1}
        TcT has computed the following interpretation:
               p(0) = [0]                  
               p(=) = [1] x1 + [0]         
             p(and) = [1] x1 + [1] x2 + [0]
            p(divp) = [2]                  
           p(false) = [0]                  
             p(not) = [1] x1 + [0]         
           p(prime) = [2] x1 + [1]         
          p(prime1) = [2] x2 + [2]         
             p(rem) = [0]                  
               p(s) = [1] x1 + [2]         
            p(true) = [5]                  
        
        Following rules are strictly oriented:
                divp(x,y) = [2]                                     
                          > [0]                                     
                          = =(rem(x,y),0())                         
        
               prime(0()) = [1]                                     
                          > [0]                                     
                          = false()                                 
        
            prime(s(0())) = [5]                                     
                          > [0]                                     
                          = false()                                 
        
           prime(s(s(x))) = [2] x + [9]                             
                          > [2] x + [6]                             
                          = prime1(s(s(x)),s(x))                    
        
            prime1(x,0()) = [2]                                     
                          > [0]                                     
                          = false()                                 
        
         prime1(x,s(0())) = [6]                                     
                          > [5]                                     
                          = true()                                  
        
        prime1(x,s(s(y))) = [2] y + [10]                            
                          > [2] y + [8]                             
                          = and(not(divp(s(s(y)),x)),prime1(x,s(y)))
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))