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


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


WORST_CASE(NON_POLY,?)
* Step 1: Sum.  WORST_CASE(NON_POLY,?)
    + Considered Problem:
        - Strict TRS:
            cond1(false(),n,l) -> cond2(gt(n,max(l)),n,l)
            cond1(true(),n,l) -> cons(n,st(s(n),l))
            cond2(false(),n,l) -> st(s(n),l)
            cond2(true(),n,l) -> nil()
            equal(0(),0()) -> true()
            equal(0(),s(y)) -> false()
            equal(s(x),0()) -> false()
            equal(s(x),s(y)) -> equal(x,y)
            gt(0(),v) -> false()
            gt(s(u),0()) -> true()
            gt(s(u),s(v)) -> gt(u,v)
            if(false(),u,v) -> v
            if(true(),u,v) -> u
            max(cons(u,l)) -> if(gt(u,max(l)),u,max(l))
            max(nil()) -> 0()
            member(n,cons(m,l)) -> or(equal(n,m),member(n,l))
            member(n,nil()) -> false()
            or(x,false()) -> x
            or(x,true()) -> true()
            sort(l) -> st(0(),l)
            st(n,l) -> cond1(member(n,l),n,l)
        - Signature:
            {cond1/3,cond2/3,equal/2,gt/2,if/3,max/1,member/2,or/2,sort/1,st/2} / {0/0,cons/2,false/0,nil/0,s/1,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {cond1,cond2,equal,gt,if,max,member,or,sort,st} and constructors {0
            ,cons,false,nil,s,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: Sum.  WORST_CASE(NON_POLY,?)
    + Considered Problem:
        - Strict TRS:
            cond1(false(),n,l) -> cond2(gt(n,max(l)),n,l)
            cond1(true(),n,l) -> cons(n,st(s(n),l))
            cond2(false(),n,l) -> st(s(n),l)
            cond2(true(),n,l) -> nil()
            equal(0(),0()) -> true()
            equal(0(),s(y)) -> false()
            equal(s(x),0()) -> false()
            equal(s(x),s(y)) -> equal(x,y)
            gt(0(),v) -> false()
            gt(s(u),0()) -> true()
            gt(s(u),s(v)) -> gt(u,v)
            if(false(),u,v) -> v
            if(true(),u,v) -> u
            max(cons(u,l)) -> if(gt(u,max(l)),u,max(l))
            max(nil()) -> 0()
            member(n,cons(m,l)) -> or(equal(n,m),member(n,l))
            member(n,nil()) -> false()
            or(x,false()) -> x
            or(x,true()) -> true()
            sort(l) -> st(0(),l)
            st(n,l) -> cond1(member(n,l),n,l)
        - Signature:
            {cond1/3,cond2/3,equal/2,gt/2,if/3,max/1,member/2,or/2,sort/1,st/2} / {0/0,cons/2,false/0,nil/0,s/1,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {cond1,cond2,equal,gt,if,max,member,or,sort,st} and constructors {0
            ,cons,false,nil,s,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 3: DecreasingLoops.  WORST_CASE(NON_POLY,?)
    + Considered Problem:
        - Strict TRS:
            cond1(false(),n,l) -> cond2(gt(n,max(l)),n,l)
            cond1(true(),n,l) -> cons(n,st(s(n),l))
            cond2(false(),n,l) -> st(s(n),l)
            cond2(true(),n,l) -> nil()
            equal(0(),0()) -> true()
            equal(0(),s(y)) -> false()
            equal(s(x),0()) -> false()
            equal(s(x),s(y)) -> equal(x,y)
            gt(0(),v) -> false()
            gt(s(u),0()) -> true()
            gt(s(u),s(v)) -> gt(u,v)
            if(false(),u,v) -> v
            if(true(),u,v) -> u
            max(cons(u,l)) -> if(gt(u,max(l)),u,max(l))
            max(nil()) -> 0()
            member(n,cons(m,l)) -> or(equal(n,m),member(n,l))
            member(n,nil()) -> false()
            or(x,false()) -> x
            or(x,true()) -> true()
            sort(l) -> st(0(),l)
            st(n,l) -> cond1(member(n,l),n,l)
        - Signature:
            {cond1/3,cond2/3,equal/2,gt/2,if/3,max/1,member/2,or/2,sort/1,st/2} / {0/0,cons/2,false/0,nil/0,s/1,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {cond1,cond2,equal,gt,if,max,member,or,sort,st} and constructors {0
            ,cons,false,nil,s,true}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          max(y){y -> cons(x,y)} =
            max(cons(x,y)) ->^+ if(gt(x,max(y)),x,max(y))
              = C[max(y) = max(y){}]
          max(y){y -> cons(x,y)} =
            max(cons(x,y)) ->^+ if(gt(x,max(y)),x,max(y))
              = C[max(y) = max(y){}]

WORST_CASE(NON_POLY,?)