WORST_CASE(?,O(n^3))
* Step 1: NaturalMI WORST_CASE(?,O(n^3))
    + Considered Problem:
        - Strict TRS:
            a__from(X) -> cons(mark(X),from(s(X)))
            a__from(X) -> from(X)
            a__length(X) -> length(X)
            a__length(cons(X,Y)) -> s(a__length1(Y))
            a__length(nil()) -> 0()
            a__length1(X) -> a__length(X)
            a__length1(X) -> length1(X)
            mark(0()) -> 0()
            mark(cons(X1,X2)) -> cons(mark(X1),X2)
            mark(from(X)) -> a__from(mark(X))
            mark(length(X)) -> a__length(X)
            mark(length1(X)) -> a__length1(X)
            mark(nil()) -> nil()
            mark(s(X)) -> s(mark(X))
        - Signature:
            {a__from/1,a__length/1,a__length1/1,mark/1} / {0/0,cons/2,from/1,length/1,length1/1,nil/0,s/1}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {a__from,a__length,a__length1,mark} and constructors {0
            ,cons,from,length,length1,nil,s}
    + 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(a__from) = {1},
          uargs(cons) = {1},
          uargs(s) = {1}
        
        Following symbols are considered usable:
          {a__from,a__length,a__length1,mark}
        TcT has computed the following interpretation:
                   p(0) = [0]                          
                          [1]                          
                          [0]                          
             p(a__from) = [1 2 0]      [1]             
                          [0 1 0] x1 + [3]             
                          [2 1 0]      [2]             
           p(a__length) = [0 0 3]      [1]             
                          [0 0 2] x1 + [2]             
                          [0 0 0]      [0]             
          p(a__length1) = [0 0 3]      [2]             
                          [0 0 2] x1 + [2]             
                          [0 0 1]      [0]             
                p(cons) = [1 1 0]      [0 0 2]      [0]
                          [0 1 0] x1 + [0 0 0] x2 + [2]
                          [0 0 0]      [0 0 1]      [2]
                p(from) = [1 2 0]      [0]             
                          [0 1 0] x1 + [3]             
                          [0 0 0]      [0]             
              p(length) = [0 0 2]      [0]             
                          [0 0 2] x1 + [2]             
                          [0 0 0]      [0]             
             p(length1) = [0 0 1]      [1]             
                          [0 0 2] x1 + [2]             
                          [0 0 0]      [0]             
                p(mark) = [1 1 0]      [0]             
                          [0 1 0] x1 + [0]             
                          [2 1 0]      [0]             
                 p(nil) = [2]                          
                          [1]                          
                          [0]                          
                   p(s) = [1 0 0]      [3]             
                          [0 1 0] x1 + [1]             
                          [0 0 0]      [0]             
        
        Following rules are strictly oriented:
                  a__from(X) = [1 2 0]     [1]              
                               [0 1 0] X + [3]              
                               [2 1 0]     [2]              
                             > [1 2 0]     [0]              
                               [0 1 0] X + [2]              
                               [0 0 0]     [2]              
                             = cons(mark(X),from(s(X)))     
        
                  a__from(X) = [1 2 0]     [1]              
                               [0 1 0] X + [3]              
                               [2 1 0]     [2]              
                             > [1 2 0]     [0]              
                               [0 1 0] X + [3]              
                               [0 0 0]     [0]              
                             = from(X)                      
        
                a__length(X) = [0 0 3]     [1]              
                               [0 0 2] X + [2]              
                               [0 0 0]     [0]              
                             > [0 0 2]     [0]              
                               [0 0 2] X + [2]              
                               [0 0 0]     [0]              
                             = length(X)                    
        
        a__length(cons(X,Y)) = [0 0 3]     [7]              
                               [0 0 2] Y + [6]              
                               [0 0 0]     [0]              
                             > [0 0 3]     [5]              
                               [0 0 2] Y + [3]              
                               [0 0 0]     [0]              
                             = s(a__length1(Y))             
        
            a__length(nil()) = [1]                          
                               [2]                          
                               [0]                          
                             > [0]                          
                               [1]                          
                               [0]                          
                             = 0()                          
        
               a__length1(X) = [0 0 3]     [2]              
                               [0 0 2] X + [2]              
                               [0 0 1]     [0]              
                             > [0 0 3]     [1]              
                               [0 0 2] X + [2]              
                               [0 0 0]     [0]              
                             = a__length(X)                 
        
               a__length1(X) = [0 0 3]     [2]              
                               [0 0 2] X + [2]              
                               [0 0 1]     [0]              
                             > [0 0 1]     [1]              
                               [0 0 2] X + [2]              
                               [0 0 0]     [0]              
                             = length1(X)                   
        
                   mark(0()) = [1]                          
                               [1]                          
                               [1]                          
                             > [0]                          
                               [1]                          
                               [0]                          
                             = 0()                          
        
           mark(cons(X1,X2)) = [1 2 0]      [0 0 2]      [2]
                               [0 1 0] X1 + [0 0 0] X2 + [2]
                               [2 3 0]      [0 0 4]      [2]
                             > [1 2 0]      [0 0 2]      [0]
                               [0 1 0] X1 + [0 0 0] X2 + [2]
                               [0 0 0]      [0 0 1]      [2]
                             = cons(mark(X1),X2)            
        
               mark(from(X)) = [1 3 0]     [3]              
                               [0 1 0] X + [3]              
                               [2 5 0]     [3]              
                             > [1 3 0]     [1]              
                               [0 1 0] X + [3]              
                               [2 3 0]     [2]              
                             = a__from(mark(X))             
        
             mark(length(X)) = [0 0 4]     [2]              
                               [0 0 2] X + [2]              
                               [0 0 6]     [2]              
                             > [0 0 3]     [1]              
                               [0 0 2] X + [2]              
                               [0 0 0]     [0]              
                             = a__length(X)                 
        
            mark(length1(X)) = [0 0 3]     [3]              
                               [0 0 2] X + [2]              
                               [0 0 4]     [4]              
                             > [0 0 3]     [2]              
                               [0 0 2] X + [2]              
                               [0 0 1]     [0]              
                             = a__length1(X)                
        
                 mark(nil()) = [3]                          
                               [1]                          
                               [5]                          
                             > [2]                          
                               [1]                          
                               [0]                          
                             = nil()                        
        
                  mark(s(X)) = [1 1 0]     [4]              
                               [0 1 0] X + [1]              
                               [2 1 0]     [7]              
                             > [1 1 0]     [3]              
                               [0 1 0] X + [1]              
                               [0 0 0]     [0]              
                             = s(mark(X))                   
        
        
        Following rules are (at-least) weakly oriented:
        

WORST_CASE(?,O(n^3))