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


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


WORST_CASE(Omega(n^1),?)
* Step 1: Sum.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__cons(X1,X2)) -> cons(activate(X1),X2)
            activate(n__incr(X)) -> incr(activate(X))
            activate(n__oddNs()) -> oddNs()
            activate(n__repItems(X)) -> repItems(activate(X))
            activate(n__take(X1,X2)) -> take(activate(X1),activate(X2))
            activate(n__zip(X1,X2)) -> zip(activate(X1),activate(X2))
            cons(X1,X2) -> n__cons(X1,X2)
            incr(X) -> n__incr(X)
            incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
            oddNs() -> incr(pairNs())
            oddNs() -> n__oddNs()
            pairNs() -> cons(0(),n__incr(n__oddNs()))
            repItems(X) -> n__repItems(X)
            repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
            repItems(nil()) -> nil()
            tail(cons(X,XS)) -> activate(XS)
            take(X1,X2) -> n__take(X1,X2)
            take(0(),XS) -> nil()
            take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
            zip(X,nil()) -> nil()
            zip(X1,X2) -> n__zip(X1,X2)
            zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
            zip(nil(),XS) -> nil()
        - Signature:
            {activate/1,cons/2,incr/1,oddNs/0,pairNs/0,repItems/1,tail/1,take/2,zip/2} / {0/0,n__cons/2,n__incr/1
            ,n__oddNs/0,n__repItems/1,n__take/2,n__zip/2,nil/0,pair/2,s/1}
        - Obligation:
             runtime complexity wrt. defined symbols {activate,cons,incr,oddNs,pairNs,repItems,tail,take
            ,zip} and constructors {0,n__cons,n__incr,n__oddNs,n__repItems,n__take,n__zip,nil,pair,s}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 2: Sum.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__cons(X1,X2)) -> cons(activate(X1),X2)
            activate(n__incr(X)) -> incr(activate(X))
            activate(n__oddNs()) -> oddNs()
            activate(n__repItems(X)) -> repItems(activate(X))
            activate(n__take(X1,X2)) -> take(activate(X1),activate(X2))
            activate(n__zip(X1,X2)) -> zip(activate(X1),activate(X2))
            cons(X1,X2) -> n__cons(X1,X2)
            incr(X) -> n__incr(X)
            incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
            oddNs() -> incr(pairNs())
            oddNs() -> n__oddNs()
            pairNs() -> cons(0(),n__incr(n__oddNs()))
            repItems(X) -> n__repItems(X)
            repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
            repItems(nil()) -> nil()
            tail(cons(X,XS)) -> activate(XS)
            take(X1,X2) -> n__take(X1,X2)
            take(0(),XS) -> nil()
            take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
            zip(X,nil()) -> nil()
            zip(X1,X2) -> n__zip(X1,X2)
            zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
            zip(nil(),XS) -> nil()
        - Signature:
            {activate/1,cons/2,incr/1,oddNs/0,pairNs/0,repItems/1,tail/1,take/2,zip/2} / {0/0,n__cons/2,n__incr/1
            ,n__oddNs/0,n__repItems/1,n__take/2,n__zip/2,nil/0,pair/2,s/1}
        - Obligation:
             runtime complexity wrt. defined symbols {activate,cons,incr,oddNs,pairNs,repItems,tail,take
            ,zip} and constructors {0,n__cons,n__incr,n__oddNs,n__repItems,n__take,n__zip,nil,pair,s}
    + Applied Processor:
        Sum {left = someStrategy, right = someStrategy}
    + Details:
        ()
* Step 3: DecreasingLoops.  WORST_CASE(Omega(n^1),?)
    + Considered Problem:
        - Strict TRS:
            activate(X) -> X
            activate(n__cons(X1,X2)) -> cons(activate(X1),X2)
            activate(n__incr(X)) -> incr(activate(X))
            activate(n__oddNs()) -> oddNs()
            activate(n__repItems(X)) -> repItems(activate(X))
            activate(n__take(X1,X2)) -> take(activate(X1),activate(X2))
            activate(n__zip(X1,X2)) -> zip(activate(X1),activate(X2))
            cons(X1,X2) -> n__cons(X1,X2)
            incr(X) -> n__incr(X)
            incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
            oddNs() -> incr(pairNs())
            oddNs() -> n__oddNs()
            pairNs() -> cons(0(),n__incr(n__oddNs()))
            repItems(X) -> n__repItems(X)
            repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
            repItems(nil()) -> nil()
            tail(cons(X,XS)) -> activate(XS)
            take(X1,X2) -> n__take(X1,X2)
            take(0(),XS) -> nil()
            take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
            zip(X,nil()) -> nil()
            zip(X1,X2) -> n__zip(X1,X2)
            zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
            zip(nil(),XS) -> nil()
        - Signature:
            {activate/1,cons/2,incr/1,oddNs/0,pairNs/0,repItems/1,tail/1,take/2,zip/2} / {0/0,n__cons/2,n__incr/1
            ,n__oddNs/0,n__repItems/1,n__take/2,n__zip/2,nil/0,pair/2,s/1}
        - Obligation:
             runtime complexity wrt. defined symbols {activate,cons,incr,oddNs,pairNs,repItems,tail,take
            ,zip} and constructors {0,n__cons,n__incr,n__oddNs,n__repItems,n__take,n__zip,nil,pair,s}
    + Applied Processor:
        DecreasingLoops {bound = AnyLoop, narrow = 10}
    + Details:
        The system has following decreasing Loops:
          activate(x){x -> n__cons(x,y)} =
            activate(n__cons(x,y)) ->^+ cons(activate(x),y)
              = C[activate(x) = activate(x){}]

WORST_CASE(Omega(n^1),?)