WORST_CASE(?,O(n^3))
* Step 1: NaturalMI WORST_CASE(?,O(n^3))
    + Considered Problem:
        - Strict TRS:
            eq(0(),0()) -> true()
            eq(0(),s(X)) -> false()
            eq(s(X),0()) -> false()
            eq(s(X),s(Y)) -> eq(X,Y)
            ifrm(false(),N,add(M,X)) -> add(M,rm(N,X))
            ifrm(true(),N,add(M,X)) -> rm(N,X)
            purge(add(N,X)) -> add(N,purge(rm(N,X)))
            purge(nil()) -> nil()
            rm(N,add(M,X)) -> ifrm(eq(N,M),N,add(M,X))
            rm(N,nil()) -> nil()
        - Signature:
            {eq/2,ifrm/3,purge/1,rm/2} / {0/0,add/2,false/0,nil/0,s/1,true/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {eq,ifrm,purge,rm} and constructors {0,add,false,nil,s
            ,true}
    + Applied Processor:
        NaturalMI {miDimension = 3, miDegree = 3, 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(add) = {2},
          uargs(ifrm) = {1},
          uargs(purge) = {1}
        
        Following symbols are considered usable:
          {eq,ifrm,purge,rm}
        TcT has computed the following interpretation:
              p(0) = [0]                                       
                     [0]                                       
                     [1]                                       
            p(add) = [0 0 0]      [1 0 2]      [0]             
                     [0 0 0] x1 + [0 0 1] x2 + [2]             
                     [0 0 1]      [0 0 1]      [2]             
             p(eq) = [0 0 0]      [0 0 1]      [0]             
                     [0 0 1] x1 + [0 1 2] x2 + [0]             
                     [0 0 0]      [0 0 0]      [0]             
          p(false) = [0]                                       
                     [0]                                       
                     [0]                                       
           p(ifrm) = [1 0 0]      [0 0 0]      [1 1 0]      [0]
                     [0 0 2] x1 + [2 2 0] x2 + [1 0 0] x3 + [3]
                     [0 0 1]      [0 0 0]      [0 0 1]      [0]
            p(nil) = [0]                                       
                     [0]                                       
                     [1]                                       
          p(purge) = [2 0 2]      [0]                          
                     [0 1 2] x1 + [0]                          
                     [0 0 1]      [0]                          
             p(rm) = [0 0 0]      [1 0 1]      [1]             
                     [2 2 0] x1 + [1 0 0] x2 + [3]             
                     [0 0 0]      [0 0 1]      [0]             
              p(s) = [0 0 0]      [0]                          
                     [0 1 0] x1 + [2]                          
                     [0 0 1]      [1]                          
           p(true) = [0]                                       
                     [0]                                       
                     [0]                                       
        
        Following rules are strictly oriented:
                     eq(0(),0()) = [1]                                    
                                   [3]                                    
                                   [0]                                    
                                 > [0]                                    
                                   [0]                                    
                                   [0]                                    
                                 = true()                                 
        
                    eq(0(),s(X)) = [0 0 1]     [1]                        
                                   [0 1 2] X + [5]                        
                                   [0 0 0]     [0]                        
                                 > [0]                                    
                                   [0]                                    
                                   [0]                                    
                                 = false()                                
        
                    eq(s(X),0()) = [0 0 0]     [1]                        
                                   [0 0 1] X + [3]                        
                                   [0 0 0]     [0]                        
                                 > [0]                                    
                                   [0]                                    
                                   [0]                                    
                                 = false()                                
        
                   eq(s(X),s(Y)) = [0 0 0]     [0 0 1]     [1]            
                                   [0 0 1] X + [0 1 2] Y + [5]            
                                   [0 0 0]     [0 0 0]     [0]            
                                 > [0 0 0]     [0 0 1]     [0]            
                                   [0 0 1] X + [0 1 2] Y + [0]            
                                   [0 0 0]     [0 0 0]     [0]            
                                 = eq(X,Y)                                
        
        ifrm(false(),N,add(M,X)) = [0 0 0]     [0 0 0]     [1 0 3]     [2]
                                   [0 0 0] M + [2 2 0] N + [1 0 2] X + [3]
                                   [0 0 1]     [0 0 0]     [0 0 1]     [2]
                                 > [0 0 0]     [1 0 3]     [1]            
                                   [0 0 0] M + [0 0 1] X + [2]            
                                   [0 0 1]     [0 0 1]     [2]            
                                 = add(M,rm(N,X))                         
        
         ifrm(true(),N,add(M,X)) = [0 0 0]     [0 0 0]     [1 0 3]     [2]
                                   [0 0 0] M + [2 2 0] N + [1 0 2] X + [3]
                                   [0 0 1]     [0 0 0]     [0 0 1]     [2]
                                 > [0 0 0]     [1 0 1]     [1]            
                                   [2 2 0] N + [1 0 0] X + [3]            
                                   [0 0 0]     [0 0 1]     [0]            
                                 = rm(N,X)                                
        
                 purge(add(N,X)) = [0 0 2]     [2 0 6]     [4]            
                                   [0 0 2] N + [0 0 3] X + [6]            
                                   [0 0 1]     [0 0 1]     [2]            
                                 > [0 0 0]     [2 0 6]     [2]            
                                   [0 0 0] N + [0 0 1] X + [2]            
                                   [0 0 1]     [0 0 1]     [2]            
                                 = add(N,purge(rm(N,X)))                  
        
                    purge(nil()) = [2]                                    
                                   [2]                                    
                                   [1]                                    
                                 > [0]                                    
                                   [0]                                    
                                   [1]                                    
                                 = nil()                                  
        
                  rm(N,add(M,X)) = [0 0 1]     [0 0 0]     [1 0 3]     [3]
                                   [0 0 0] M + [2 2 0] N + [1 0 2] X + [3]
                                   [0 0 1]     [0 0 0]     [0 0 1]     [2]
                                 > [0 0 1]     [0 0 0]     [1 0 3]     [2]
                                   [0 0 0] M + [2 2 0] N + [1 0 2] X + [3]
                                   [0 0 1]     [0 0 0]     [0 0 1]     [2]
                                 = ifrm(eq(N,M),N,add(M,X))               
        
                     rm(N,nil()) = [0 0 0]     [2]                        
                                   [2 2 0] N + [3]                        
                                   [0 0 0]     [1]                        
                                 > [0]                                    
                                   [0]                                    
                                   [1]                                    
                                 = nil()                                  
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^3))