Deriv Compl Full Rewri 33144 pair #381922144

details

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

run statistics

property	value
solver	tct 2018-07-13
configuration	tct_dc
runtime (wallclock)	30.1147799492 seconds
cpu usage	95.244248979
max memory	3.4451456E7

stage attributes

key	value
output-size	3848
starexec-result	WORST_CASE(?,O(n^1))

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^1))
* Step 1: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            b() -> a()
            f(a()) -> g(a())
            g(b()) -> f(b())
        - Signature:
            {b/0,f/1,g/1} / {a/0}
        - Obligation:
             derivational complexity wrt. signature {a,b,f,g}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind triangular matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
          p(a) = [1]           
                 [0]           
          p(b) = [9]           
                 [0]           
          p(f) = [1 0] x1 + [0]
                 [0 0]      [0]
          p(g) = [1 0] x1 + [0]
                 [0 0]      [0]
        
        Following rules are strictly oriented:
        b() = [9]
              [0]
            > [1]
              [0]
            = a()
        
        
        Following rules are (at-least) weakly oriented:
        f(a()) =  [1]   
                  [0]   
               >= [1]   
                  [0]   
               =  g(a())
        
        g(b()) =  [9]   
                  [0]   
               >= [9]   
                  [0]   
               =  f(b())
        
* Step 2: NaturalMI WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            f(a()) -> g(a())
            g(b()) -> f(b())
        - Weak TRS:
            b() -> a()
        - Signature:
            {b/0,f/1,g/1} / {a/0}
        - Obligation:
             derivational complexity wrt. signature {a,b,f,g}
    + Applied Processor:
        NaturalMI {miDimension = 2, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Just any strict-rules}
    + Details:
        We apply a matrix interpretation of kind triangular matrix interpretation (containing no more than 1 non-zero interpretation-entries in the diagonal of the component-wise maxima):
        
        Following symbols are considered usable:
          all
        TcT has computed the following interpretation:
          p(a) = [0]            
                 [0]            
          p(b) = [0]            
                 [3]            
          p(f) = [1 1] x1 + [13]
                 [0 0]      [4] 
          p(g) = [1 8] x1 + [4] 
                 [0 0]      [4] 
        
        Following rules are strictly oriented:
        f(a()) = [13]  
                 [4]   
               > [4]   
                 [4]   
               = g(a())
        
        g(b()) = [28]  
                 [4]   
               > [16]  
                 [4]   
               = f(b())
        
        
        Following rules are (at-least) weakly oriented:
        b() =  [0]
               [3]

popout

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

job log

popout

actions all output return to Deriv Compl Full Rewri 33144