WORST_CASE(?,O(n^1))
* Step 1: Ara WORST_CASE(?,O(n^1))
    + Considered Problem:
        - Strict TRS:
            mem(x,nil()) -> false()
            mem(x,set(y)) -> =(x,y)
            mem(x,union(y,z)) -> or(mem(x,y),mem(x,z))
            or(x,true()) -> true()
            or(false(),false()) -> false()
            or(true(),y) -> true()
        - Signature:
            {mem/2,or/2} / {=/2,false/0,nil/0,set/1,true/0,union/2}
        - Obligation:
            innermost runtime complexity wrt. defined symbols {mem,or} and constructors {=,false,nil,set,true,union}
    + Applied Processor:
        Ara {araHeuristics = NoHeuristics, minDegree = 1, maxDegree = 2, araTimeout = 5, araRuleShifting = Nothing}
    + Details:
        Signatures used:
        ----------------
          = :: ["A"(0) x "A"(0)] -(0)-> "A"(14)
          false :: [] -(0)-> "A"(0)
          false :: [] -(0)-> "A"(14)
          mem :: ["A"(0) x "A"(15)] -(1)-> "A"(0)
          nil :: [] -(0)-> "A"(15)
          or :: ["A"(0) x "A"(0)] -(9)-> "A"(0)
          set :: ["A"(0)] -(0)-> "A"(15)
          true :: [] -(0)-> "A"(0)
          true :: [] -(0)-> "A"(14)
          union :: ["A"(15) x "A"(15)] -(15)-> "A"(15)
        
        
        Cost-free Signatures used:
        --------------------------
        
        
        
        Base Constructor Signatures used:
        ---------------------------------
          "=_A" :: ["A"(0) x "A"(0)] -(0)-> "A"(0)
          "false_A" :: [] -(0)-> "A"(1)
          "nil_A" :: [] -(0)-> "A"(1)
          "set_A" :: ["A"(0)] -(0)-> "A"(1)
          "true_A" :: [] -(0)-> "A"(1)
          "union_A" :: ["A"(1) x "A"(1)] -(1)-> "A"(1)
        

WORST_CASE(?,O(n^1))