WORST_CASE(?,O(n^1))
* Step 1: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            dx(X) -> one()
            dx(a()) -> zero()
            dx(div(ALPHA,BETA)) -> minus(div(dx(ALPHA),BETA),times(ALPHA,div(dx(BETA),exp(BETA,two()))))
            dx(exp(ALPHA,BETA)) -> plus(times(BETA,times(exp(ALPHA,minus(BETA,one())),dx(ALPHA)))
                                       ,times(exp(ALPHA,BETA),times(ln(ALPHA),dx(BETA))))
            dx(ln(ALPHA)) -> div(dx(ALPHA),ALPHA)
            dx(minus(ALPHA,BETA)) -> minus(dx(ALPHA),dx(BETA))
            dx(neg(ALPHA)) -> neg(dx(ALPHA))
            dx(plus(ALPHA,BETA)) -> plus(dx(ALPHA),dx(BETA))
            dx(times(ALPHA,BETA)) -> plus(times(BETA,dx(ALPHA)),times(ALPHA,dx(BETA)))
        - Signature:
            {dx/1} / {a/0,div/2,exp/2,ln/1,minus/2,neg/1,one/0,plus/2,times/2,two/0,zero/0}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {dx} and constructors {a,div,exp,ln,minus,neg,one,plus
            ,times,two,zero}
    + Applied Processor:
        Ara {araHeuristics = NoHeuristics, minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          a :: [] -(0)-> "A"(15)
          div :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
          div :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          dx :: ["A"(15)] -(8)-> "A"(0)
          exp :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
          exp :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          ln :: ["A"(15)] -(15)-> "A"(15)
          ln :: ["A"(0)] -(0)-> "A"(0)
          minus :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
          minus :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          neg :: ["A"(15)] -(15)-> "A"(15)
          neg :: ["A"(0)] -(0)-> "A"(0)
          one :: [] -(0)-> "A"(6)
          one :: [] -(0)-> "A"(12)
          plus :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
          plus :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          times :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
          times :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          two :: [] -(0)-> "A"(12)
          zero :: [] -(0)-> "A"(6)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "a_A" :: [] -(0)-> "A"(1)
          "div_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "exp_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "ln_A" :: ["A"(1)] -(1)-> "A"(1)
          "minus_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "neg_A" :: ["A"(1)] -(1)-> "A"(1)
          "one_A" :: [] -(0)-> "A"(1)
          "plus_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "times_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
          "two_A" :: [] -(0)-> "A"(1)
          "zero_A" :: [] -(0)-> "A"(1)
        

WORST_CASE(?,O(n^1))