/export/starexec/sandbox/solver/bin/starexec_run_tct_dci /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


WORST_CASE(?,O(n^2))
* Step 1: NaturalMI.  WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            add() -> app(curry(),plus())
            app(app(app(curry(),f),x),y) -> app(app(f,x),y)
            app(app(plus(),0()),y) -> y
            app(app(plus(),app(s(),x)),y) -> app(s(),app(app(plus(),x),y))
        - Signature:
            {add/0,app/2} / {0/0,curry/0,plus/0,s/0}
        - Obligation:
            innermost derivational complexity wrt. signature {0,add,app,curry,plus,s}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind triangular matrix interpretation:
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
              p(0) = [13]                 
            p(add) = [15]                 
            p(app) = [1] x1 + [1] x2 + [9]
          p(curry) = [4]                  
           p(plus) = [0]                  
              p(s) = [3]                  
        
        Following rules are strictly oriented:
                               add() = [15]                        
                                     > [13]                        
                                     = app(curry(),plus())         
        
        app(app(app(curry(),f),x),y) = [1] f + [1] x + [1] y + [31]
                                     > [1] f + [1] x + [1] y + [18]
                                     = app(app(f,x),y)             
        
              app(app(plus(),0()),y) = [1] y + [31]                
                                     > [1] y + [0]                 
                                     = y                           
        
        
        Following rules are (at-least) weakly oriented:
        app(app(plus(),app(s(),x)),y) =  [1] x + [1] y + [30]         
                                      >= [1] x + [1] y + [30]         
                                      =  app(s(),app(app(plus(),x),y))
        
* Step 2: NaturalMI.  WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            app(app(plus(),app(s(),x)),y) -> app(s(),app(app(plus(),x),y))
        - Weak TRS:
            add() -> app(curry(),plus())
            app(app(app(curry(),f),x),y) -> app(app(f,x),y)
            app(app(plus(),0()),y) -> y
        - Signature:
            {add/0,app/2} / {0/0,curry/0,plus/0,s/0}
        - Obligation:
            innermost derivational complexity wrt. signature {0,add,app,curry,plus,s}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 2, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind triangular matrix interpretation:
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
              p(0) = [2]                      
                     [1]                      
            p(add) = [5]                      
                     [3]                      
            p(app) = [1 2] x1 + [1 0] x2 + [0]
                     [0 1]      [0 1]      [2]
          p(curry) = [2]                      
                     [0]                      
           p(plus) = [1]                      
                     [1]                      
              p(s) = [1]                      
                     [0]                      
        
        Following rules are strictly oriented:
        app(app(plus(),app(s(),x)),y) = [1 2] x + [1 0] y + [14]     
                                        [0 1]     [0 1]     [7]      
                                      > [1 2] x + [1 0] y + [10]     
                                        [0 1]     [0 1]     [7]      
                                      = app(s(),app(app(plus(),x),y))
        
        
        Following rules are (at-least) weakly oriented:
                               add() =  [5]                               
                                        [3]                               
                                     >= [3]                               
                                        [3]                               
                                     =  app(curry(),plus())               
        
        app(app(app(curry(),f),x),y) =  [1 4] f + [1 2] x + [1 0] y + [14]
                                        [0 1]     [0 1]     [0 1]     [6] 
                                     >= [1 4] f + [1 2] x + [1 0] y + [4] 
                                        [0 1]     [0 1]     [0 1]     [4] 
                                     =  app(app(f,x),y)                   
        
              app(app(plus(),0()),y) =  [1 0] y + [13]                    
                                        [0 1]     [6]                     
                                     >= [1 0] y + [0]                     
                                        [0 1]     [0]                     
                                     =  y                                 
        
* Step 3: EmptyProcessor.  WORST_CASE(?,O(1))
    + Considered Problem:
        - Weak TRS:
            add() -> app(curry(),plus())
            app(app(app(curry(),f),x),y) -> app(app(f,x),y)
            app(app(plus(),0()),y) -> y
            app(app(plus(),app(s(),x)),y) -> app(s(),app(app(plus(),x),y))
        - Signature:
            {add/0,app/2} / {0/0,curry/0,plus/0,s/0}
        - Obligation:
            innermost derivational complexity wrt. signature {0,add,app,curry,plus,s}
    + Applied Processor:
        EmptyProcessor
    + Details:
        The problem is already closed. The intended complexity is O(1).

WORST_CASE(?,O(n^2))