Deriv Compl Full Rewri 33144 pair #381921952

details

property	value
status	complete
benchmark	005.xml
ran by	Akihisa Yamada
cpu timeout	1200 seconds
wallclock timeout	300 seconds
memory limit	137438953472 bytes
execution host	n055.star.cs.uiowa.edu
space	AotoYamada_05

run statistics

property	value
solver	tct 2018-07-13
configuration	tct_dc
runtime (wallclock)	33.2723591328 seconds
cpu usage	106.276161038
max memory	1.0061824E8

stage attributes

key	value
output-size	6087
starexec-result	WORST_CASE(?,O(n^2))

output

/export/starexec/sandbox/solver/bin/starexec_run_tct_dc /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:
             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:
             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())

popout

output may be truncated. 'popout' for the full output.

job log

popout

actions all output return to Deriv Compl Full Rewri 33144