Deriv Compl Full Rewri 33144 pair #381922227

details

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

run statistics

property	value
solver	tct 2018-07-13
configuration	tct_dc
runtime (wallclock)	53.1433680058 seconds
cpu usage	136.929307503
max memory	1.54095616E8

stage attributes

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

output

/export/starexec/sandbox2/solver/bin/starexec_run_tct_dc /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files


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


WORST_CASE(?,O(n^2))
* Step 1: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
            activate(n__f(X)) -> f(activate(X))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
             derivational complexity wrt. signature {a,activate,c,f,g,n__a,n__f,n__g}
    + 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(a) = [8]         
          p(activate) = [1] x1 + [9]
                 p(c) = [1] x1 + [0]
                 p(f) = [1] x1 + [1]
                 p(g) = [1] x1 + [8]
              p(n__a) = [0]         
              p(n__f) = [1] x1 + [1]
              p(n__g) = [1] x1 + [8]
        
        Following rules are strictly oriented:
                     a() = [8]        
                         > [0]        
                         = n__a()     
        
             activate(X) = [1] X + [9]
                         > [1] X + [0]
                         = X          
        
        activate(n__a()) = [9]        
                         > [8]        
                         = a()        
        
        
        Following rules are (at-least) weakly oriented:
        activate(n__f(X)) =  [1] X + [10]               
                          >= [1] X + [10]               
                          =  f(activate(X))             
        
        activate(n__g(X)) =  [1] X + [17]               
                          >= [1] X + [17]               
                          =  g(activate(X))             
        
                     f(X) =  [1] X + [1]                
                          >= [1] X + [1]                
                          =  n__f(X)                    
        
                f(f(a())) =  [10]                       
                          >= [10]                       
                          =  c(n__f(n__g(n__f(n__a()))))
        
                     g(X) =  [1] X + [8]                
                          >= [1] X + [8]                
                          =  n__g(X)                    
        
* Step 2: NaturalMI WORST_CASE(?,O(n^2))
    + Considered Problem:
        - Strict TRS:
            activate(n__f(X)) -> f(activate(X))
            activate(n__g(X)) -> g(activate(X))
            f(X) -> n__f(X)
            f(f(a())) -> c(n__f(n__g(n__f(n__a()))))
            g(X) -> n__g(X)
        - Weak TRS:
            a() -> n__a()
            activate(X) -> X
            activate(n__a()) -> a()
        - Signature:
            {a/0,activate/1,f/1,g/1} / {c/1,n__a/0,n__f/1,n__g/1}
        - Obligation:
             derivational complexity wrt. signature {a,activate,c,f,g,n__a,n__f,n__g}
    + 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(a) = [4]         
          p(activate) = [1] x1 + [2]

popout

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

job log

popout

actions all output return to Deriv Compl Full Rewri 33144