WORST_CASE(Omega(n^1),?) * Step 1: Sum. WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) from(X) -> cons(X,from(s(X))) fst(0(),Z) -> nil() fst(s(X),cons(Y,Z)) -> cons(Y,fst(X,Z)) len(cons(X,Z)) -> s(len(Z)) len(nil()) -> 0() - Signature: {add/2,from/1,fst/2,len/1} / {0/0,cons/2,nil/0,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,from,fst,len} and constructors {0,cons,nil,s} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () * Step 2: Sum. WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) from(X) -> cons(X,from(s(X))) fst(0(),Z) -> nil() fst(s(X),cons(Y,Z)) -> cons(Y,fst(X,Z)) len(cons(X,Z)) -> s(len(Z)) len(nil()) -> 0() - Signature: {add/2,from/1,fst/2,len/1} / {0/0,cons/2,nil/0,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,from,fst,len} and constructors {0,cons,nil,s} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 2.a:1: Ara. MAYBE + Considered Problem: - Strict TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) from(X) -> cons(X,from(s(X))) fst(0(),Z) -> nil() fst(s(X),cons(Y,Z)) -> cons(Y,fst(X,Z)) len(cons(X,Z)) -> s(len(Z)) len(nil()) -> 0() - Signature: {add/2,from/1,fst/2,len/1} / {0/0,cons/2,nil/0,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,from,fst,len} and constructors {0,cons,nil,s} + Applied Processor: Ara {minDegree = 1, maxDegree = 3, araTimeout = 15, araRuleShifting = Just 1, isBestCase = True, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "0") :: [] -(0)-> "A"(0) F (TrsFun "add") :: ["A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "cons") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "cons") :: ["A"(0) x "A"(1)] -(1)-> "A"(1) F (TrsFun "from") :: ["A"(0)] -(1)-> "A"(0) F (TrsFun "fst") :: ["A"(0) x "A"(0)] -(1)-> "A"(0) F (TrsFun "len") :: ["A"(1)] -(1)-> "A"(0) F (TrsFun "main") :: ["A"(1)] -(1)-> "A"(0) F (TrsFun "nil") :: [] -(0)-> "A"(1) F (TrsFun "nil") :: [] -(0)-> "A"(0) F (TrsFun "s") :: ["A"(0)] -(0)-> "A"(0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) from(X) -> cons(X,from(s(X))) fst(0(),Z) -> nil() fst(s(X),cons(Y,Z)) -> cons(Y,fst(X,Z)) len(cons(X,Z)) -> s(len(Z)) len(nil()) -> 0() main(x1) -> len(x1) 2. Weak: ** Step 2.b:1: DecreasingLoops. WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: add(0(),X) -> X add(s(X),Y) -> s(add(X,Y)) from(X) -> cons(X,from(s(X))) fst(0(),Z) -> nil() fst(s(X),cons(Y,Z)) -> cons(Y,fst(X,Z)) len(cons(X,Z)) -> s(len(Z)) len(nil()) -> 0() - Signature: {add/2,from/1,fst/2,len/1} / {0/0,cons/2,nil/0,s/1} - Obligation: innermost runtime complexity wrt. defined symbols {add,from,fst,len} and constructors {0,cons,nil,s} + Applied Processor: DecreasingLoops {bound = AnyLoop, narrow = 10} + Details: The system has following decreasing Loops: add(x,y){x -> s(x)} = add(s(x),y) ->^+ s(add(x,y)) = C[add(x,y) = add(x,y){}] WORST_CASE(Omega(n^1),?)