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


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


WORST_CASE(Omega(n^1),?)
* Step 1: Sum.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            +(x,#()) -> x
            +(#(),x) -> x
            +(+(x,y),z) -> +(x,+(y,z))
            +(0(x),0(y)) -> 0(+(x,y))
            +(0(x),1(y)) -> 1(+(x,y))
            +(1(x),0(y)) -> 1(+(x,y))
            +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
            -(x,#()) -> x
            -(#(),x) -> #()
            -(0(x),0(y)) -> 0(-(x,y))
            -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
            -(1(x),0(y)) -> 1(-(x,y))
            -(1(x),1(y)) -> 0(-(x,y))
            0(#()) -> #()
            ge(x,#()) -> true()
            ge(#(),0(x)) -> ge(#(),x)
            ge(#(),1(x)) -> false()
            ge(0(x),0(y)) -> ge(x,y)
            ge(0(x),1(y)) -> not(ge(y,x))
            ge(1(x),0(y)) -> ge(x,y)
            ge(1(x),1(y)) -> ge(x,y)
            if(false(),x,y) -> y
            if(true(),x,y) -> x
            log(x) -> -(log'(x),1(#()))
            log'(#()) -> #()
            log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
            log'(1(x)) -> +(log'(x),1(#()))
            not(false()) -> true()
            not(true()) -> false()
        - Signature:
            {+/2,-/2,0/1,ge/2,if/3,log/1,log'/1,not/1} / {#/0,1/1,false/0,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {+,-,0,ge,if,log,log',not} and constructors {#,1,false,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: Sum.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            +(x,#()) -> x
            +(#(),x) -> x
            +(+(x,y),z) -> +(x,+(y,z))
            +(0(x),0(y)) -> 0(+(x,y))
            +(0(x),1(y)) -> 1(+(x,y))
            +(1(x),0(y)) -> 1(+(x,y))
            +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
            -(x,#()) -> x
            -(#(),x) -> #()
            -(0(x),0(y)) -> 0(-(x,y))
            -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
            -(1(x),0(y)) -> 1(-(x,y))
            -(1(x),1(y)) -> 0(-(x,y))
            0(#()) -> #()
            ge(x,#()) -> true()
            ge(#(),0(x)) -> ge(#(),x)
            ge(#(),1(x)) -> false()
            ge(0(x),0(y)) -> ge(x,y)
            ge(0(x),1(y)) -> not(ge(y,x))
            ge(1(x),0(y)) -> ge(x,y)
            ge(1(x),1(y)) -> ge(x,y)
            if(false(),x,y) -> y
            if(true(),x,y) -> x
            log(x) -> -(log'(x),1(#()))
            log'(#()) -> #()
            log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
            log'(1(x)) -> +(log'(x),1(#()))
            not(false()) -> true()
            not(true()) -> false()
        - Signature:
            {+/2,-/2,0/1,ge/2,if/3,log/1,log'/1,not/1} / {#/0,1/1,false/0,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {+,-,0,ge,if,log,log',not} and constructors {#,1,false,true}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 3: DecreasingLoops.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            +(x,#()) -> x
            +(#(),x) -> x
            +(+(x,y),z) -> +(x,+(y,z))
            +(0(x),0(y)) -> 0(+(x,y))
            +(0(x),1(y)) -> 1(+(x,y))
            +(1(x),0(y)) -> 1(+(x,y))
            +(1(x),1(y)) -> 0(+(+(x,y),1(#())))
            -(x,#()) -> x
            -(#(),x) -> #()
            -(0(x),0(y)) -> 0(-(x,y))
            -(0(x),1(y)) -> 1(-(-(x,y),1(#())))
            -(1(x),0(y)) -> 1(-(x,y))
            -(1(x),1(y)) -> 0(-(x,y))
            0(#()) -> #()
            ge(x,#()) -> true()
            ge(#(),0(x)) -> ge(#(),x)
            ge(#(),1(x)) -> false()
            ge(0(x),0(y)) -> ge(x,y)
            ge(0(x),1(y)) -> not(ge(y,x))
            ge(1(x),0(y)) -> ge(x,y)
            ge(1(x),1(y)) -> ge(x,y)
            if(false(),x,y) -> y
            if(true(),x,y) -> x
            log(x) -> -(log'(x),1(#()))
            log'(#()) -> #()
            log'(0(x)) -> if(ge(x,1(#())),+(log'(x),1(#())),#())
            log'(1(x)) -> +(log'(x),1(#()))
            not(false()) -> true()
            not(true()) -> false()
        - Signature:
            {+/2,-/2,0/1,ge/2,if/3,log/1,log'/1,not/1} / {#/0,1/1,false/0,true/0}
        - Obligation:
             runtime complexity wrt. defined symbols {+,-,0,ge,if,log,log',not} and constructors {#,1,false,true}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          +(x,y){x -> 1(x),y -> 1(y)} =
            +(1(x),1(y)) ->^+ 0(+(+(x,y),1(#())))
              = C[+(x,y) = +(x,y){}]

WORST_CASE(Omega(n^1),?)