WORST_CASE(?,O(n^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            =(.(x,y),.(u(),v())) -> and(=(x,u()),=(y,v()))
            =(.(x,y),nil()) -> false()
            =(nil(),.(y,z)) -> false()
            =(nil(),nil()) -> true()
            del(.(x,.(y,z))) -> f(=(x,y),x,y,z)
            f(false(),x,y,z) -> .(x,del(.(y,z)))
            f(true(),x,y,z) -> del(.(y,z))
        - Signature:
            {=/2,del/1,f/4} / {./2,and/2,false/0,nil/0,true/0,u/0,v/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {=,del,f} and constructors {.,and,false,nil,true,u,v}
    + 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(.) = {2},
          uargs(f) = {1}
        
        Following symbols are considered usable:
          {=,del,f}
        TcT has computed the following interpretation:
              p(.) = [1] x2 + [4]          
              p(=) = [1]                   
            p(and) = [0]                   
            p(del) = [2] x1 + [0]          
              p(f) = [2] x1 + [2] x4 + [13]
          p(false) = [0]                   
            p(nil) = [1]                   
           p(true) = [0]                   
              p(u) = [1]                   
              p(v) = [10]                  
        
        Following rules are strictly oriented:
        =(.(x,y),.(u(),v())) = [1]                   
                             > [0]                   
                             = and(=(x,u()),=(y,v()))
        
             =(.(x,y),nil()) = [1]                   
                             > [0]                   
                             = false()               
        
             =(nil(),.(y,z)) = [1]                   
                             > [0]                   
                             = false()               
        
              =(nil(),nil()) = [1]                   
                             > [0]                   
                             = true()                
        
            del(.(x,.(y,z))) = [2] z + [16]          
                             > [2] z + [15]          
                             = f(=(x,y),x,y,z)       
        
            f(false(),x,y,z) = [2] z + [13]          
                             > [2] z + [12]          
                             = .(x,del(.(y,z)))      
        
             f(true(),x,y,z) = [2] z + [13]          
                             > [2] z + [8]           
                             = del(.(y,z))           
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^1))