WORST_CASE(?,O(n^1))
* Step 1: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            deleteMin#1(E()) -> ErrorHeap()
            deleteMin#1(T(E(),x6,x8)) -> x8
            deleteMin#1(T(T(E(),x24,x28),x12,x16)) -> T(x28,x12,x16)
            deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) -> T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))
            main(x0) -> deleteMin#1(x0)
        - Signature:
            {deleteMin#1/1,main/1} / {E/0,ErrorHeap/0,T/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {deleteMin#1,main} and constructors {E,ErrorHeap,T}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(T) = {1}
        
        Following symbols are considered usable:
          {deleteMin#1,main}
        TcT has computed the following interpretation:
                    p(E) = 0       
            p(ErrorHeap) = 0       
                    p(T) = x1 + x3 
          p(deleteMin#1) = 9 + 8*x1
                 p(main) = 9 + 8*x1
        
        Following rules are strictly oriented:
                              deleteMin#1(E()) = 9                
                                               > 0                
                                               = ErrorHeap()      
        
                     deleteMin#1(T(E(),x6,x8)) = 9 + 8*x8         
                                               > x8               
                                               = x8               
        
        deleteMin#1(T(T(E(),x24,x28),x12,x16)) = 9 + 8*x16 + 8*x28
                                               > x16 + x28        
                                               = T(x28,x12,x16)   
        
        
        Following rules are (at-least) weakly oriented:
        deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) =  9 + 8*x16 + 8*x28 + 8*x32 + 8*x40                
                                                          >= 9 + x16 + x28 + 8*x32 + 8*x40                    
                                                          =  T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))
        
                                                 main(x0) =  9 + 8*x0                                         
                                                          >= 9 + 8*x0                                         
                                                          =  deleteMin#1(x0)                                  
        
* Step 2: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) -> T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))
            main(x0) -> deleteMin#1(x0)
        - Weak TRS:
            deleteMin#1(E()) -> ErrorHeap()
            deleteMin#1(T(E(),x6,x8)) -> x8
            deleteMin#1(T(T(E(),x24,x28),x12,x16)) -> T(x28,x12,x16)
        - Signature:
            {deleteMin#1/1,main/1} / {E/0,ErrorHeap/0,T/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {deleteMin#1,main} and constructors {E,ErrorHeap,T}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(T) = {1}
        
        Following symbols are considered usable:
          {deleteMin#1,main}
        TcT has computed the following interpretation:
                    p(E) = 0               
            p(ErrorHeap) = 7               
                    p(T) = 1 + x1 + x2 + x3
          p(deleteMin#1) = 7 + 8*x1        
                 p(main) = 7 + 8*x1        
        
        Following rules are strictly oriented:
        deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) = 31 + 8*x12 + 8*x16 + 8*x24 + 8*x28 + 8*x32 + 8*x36 + 8*x40
                                                          > 17 + x12 + x16 + x24 + x28 + 8*x32 + 8*x36 + 8*x40        
                                                          = T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))         
        
        
        Following rules are (at-least) weakly oriented:
                              deleteMin#1(E()) =  7                                 
                                               >= 7                                 
                                               =  ErrorHeap()                       
        
                     deleteMin#1(T(E(),x6,x8)) =  15 + 8*x6 + 8*x8                  
                                               >= x8                                
                                               =  x8                                
        
        deleteMin#1(T(T(E(),x24,x28),x12,x16)) =  23 + 8*x12 + 8*x16 + 8*x24 + 8*x28
                                               >= 1 + x12 + x16 + x28               
                                               =  T(x28,x12,x16)                    
        
                                      main(x0) =  7 + 8*x0                          
                                               >= 7 + 8*x0                          
                                               =  deleteMin#1(x0)                   
        
* Step 3: NaturalPI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            main(x0) -> deleteMin#1(x0)
        - Weak TRS:
            deleteMin#1(E()) -> ErrorHeap()
            deleteMin#1(T(E(),x6,x8)) -> x8
            deleteMin#1(T(T(E(),x24,x28),x12,x16)) -> T(x28,x12,x16)
            deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) -> T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))
        - Signature:
            {deleteMin#1/1,main/1} / {E/0,ErrorHeap/0,T/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {deleteMin#1,main} and constructors {E,ErrorHeap,T}
    + Applied Processor:
        NaturalPI {shape = Linear, restrict = Restrict, uargs = UArgs, urules = URules, selector = Just any strict-rules}
    + Details:
        We apply a polynomial interpretation of kind constructor-based(linear):
        The following argument positions are considered usable:
          uargs(T) = {1}
        
        Following symbols are considered usable:
          {deleteMin#1,main}
        TcT has computed the following interpretation:
                    p(E) = 0               
            p(ErrorHeap) = 2               
                    p(T) = 1 + x1 + x2 + x3
          p(deleteMin#1) = 2 + 8*x1        
                 p(main) = 13 + 9*x1       
        
        Following rules are strictly oriented:
        main(x0) = 13 + 9*x0      
                 > 2 + 8*x0       
                 = deleteMin#1(x0)
        
        
        Following rules are (at-least) weakly oriented:
                                         deleteMin#1(E()) =  2                                                         
                                                          >= 2                                                         
                                                          =  ErrorHeap()                                               
        
                                deleteMin#1(T(E(),x6,x8)) =  10 + 8*x6 + 8*x8                                          
                                                          >= x8                                                        
                                                          =  x8                                                        
        
                   deleteMin#1(T(T(E(),x24,x28),x12,x16)) =  18 + 8*x12 + 8*x16 + 8*x24 + 8*x28                        
                                                          >= 1 + x12 + x16 + x28                                       
                                                          =  T(x28,x12,x16)                                            
        
        deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) =  26 + 8*x12 + 8*x16 + 8*x24 + 8*x28 + 8*x32 + 8*x36 + 8*x40
                                                          >= 12 + x12 + x16 + x24 + x28 + 8*x32 + 8*x36 + 8*x40        
                                                          =  T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))         
        
* Step 4: EmptyProcessor WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            deleteMin#1(E()) -> ErrorHeap()
            deleteMin#1(T(E(),x6,x8)) -> x8
            deleteMin#1(T(T(E(),x24,x28),x12,x16)) -> T(x28,x12,x16)
            deleteMin#1(T(T(T(x32,x36,x40),x24,x28),x12,x16)) -> T(deleteMin#1(T(x32,x36,x40)),x24,T(x28,x12,x16))
            main(x0) -> deleteMin#1(x0)
        - Signature:
            {deleteMin#1/1,main/1} / {E/0,ErrorHeap/0,T/3}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {deleteMin#1,main} and constructors {E,ErrorHeap,T}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^1))