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


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


MAYBE
* Step 1: DecomposeCP.  MAYBE
    + Considered Problem:
        - Strict TRS:
            a() -> b()
            f(a()) -> f(a())
        - Signature:
            {a/0,f/1} / {b/0}
        - Obligation:
             derivational complexity wrt. signature {a,b,f}
    + Applied Processor:
        DecomposeCP {onSelectionCP_ = any strict-rules, withBoundCP_ = RelativeMul, withCP_ = NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Nothing}}
    + Details:
        We first use the processor NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Nothing} to orient following rules strictly:
          
          a() -> b()
        The Processor induces the complexity certificate TIME (?,O(n^1))
        BEST_CASE TIME (?,?)
        SPACE(?,?)
        
        Observe that Problem (R) is non-size-increasing. Once the complexity of (R) has been assessed, it suffices
        to consider only rules whose complexity has not been estimated in (R) resulting in the following Problem
        (S). Overall the certificate is obtained by multiplication.
        Problem (S)
          - Strict TRS:
              f(a()) -> f(a())
          - Signature:
              {a/0,f/1} / {b/0}
          - Obligation:
               derivational complexity wrt. signature {a,b,f}
** Step 1.a:1: NaturalMI.  WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            a() -> b()
            f(a()) -> f(a())
        - Signature:
            {a/0,f/1} / {b/0}
        - Obligation:
             derivational complexity wrt. signature {a,b,f}
    + Applied Processor:
        NaturalMI {miDimension = 1, miDegree = 1, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Just first alternative for decompose on 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) = [12]        
          p(b) = [3]         
          p(f) = [1] x1 + [7]
        
        Following rules are strictly oriented:
        a() = [12]
            > [3] 
            = b() 
        
        
        Following rules are (at-least) weakly oriented:
        f(a()) =  [19]  
               >= [19]  
               =  f(a())
        
** Step 1.a:2: Assumption.  WORST_CASE(?,O(1))
    + Considered Problem:
        - Strict TRS:
            f(a()) -> f(a())
        - Weak TRS:
            a() -> b()
        - Signature:
            {a/0,f/1} / {b/0}
        - Obligation:
             derivational complexity wrt. signature {a,b,f}
    + Applied Processor:
        Assumption {assumed = Certificate {spaceUB = Unknown, spaceLB = Unknown, timeUB = Poly (Just 0), timeLB = Unknown, timeBCUB = Unknown, timeBCLB = Unknown}}
    + Details:
        ()

** Step 1.b:1: Failure MAYBE
  + Considered Problem:
      - Strict TRS:
          f(a()) -> f(a())
      - Signature:
          {a/0,f/1} / {b/0}
      - Obligation:
           derivational complexity wrt. signature {a,b,f}
  + Applied Processor:
      DecomposeCP {onSelectionCP_ = any strict-rules, withBoundCP_ = RelativeMul, withCP_ = NaturalMI {miDimension = 4, miDegree = 4, miKind = Algebraic, uargs = NoUArgs, urules = NoURules, selector = Nothing}}
  + Details:
      application of cp failed
MAYBE