/export/starexec/sandbox/solver/bin/starexec_run_tct_rci /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1),O(n^1)) * Step 1: Sum. WORST_CASE(Omega(n^1),O(n^1)) + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () ** Step 1.a:1: Sum. WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Sum {left = someStrategy, right = someStrategy} + Details: () *** Step 1.a:1.a:1: Decompose. MAYBE + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Decompose {onSelection = any filtered on not main function of strict-rules, withBound = BestCaseLBMax} + Details: We analyse the complexity of following sub-problems (R) and (S). For the best-case lower bound analysis the maximum derivation length of either sub-problem provides a lower bound in terms of derivation length of the original TRS. Problem (R) - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 - Weak TRS: main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} Problem (S) - Strict TRS: main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} **** Step 1.a:1.a:1.a:1: Ara. MAYBE + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 - Weak TRS: main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Ara {minDegree = 1, maxDegree = 3, araTimeout = 15, araRuleShifting = Just 1, isBestCase = True, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "Cons") :: ["A"(0) x "A"(1)] -(1)-> "A"(1) F (TrsFun "Cons") :: ["A"(0) x "A"(0)] -(0)-> "A"(0) F (TrsFun "Nil") :: [] -(0)-> "A"(1) F (TrsFun "Nil") :: [] -(0)-> "A"(0) F (TrsFun "foldl#3") :: ["A"(0) x "A"(1)] -(1)-> "A"(0) F (TrsFun "main") :: ["A"(1)] -(0)-> "A"(0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 2. Weak: **** Step 1.a:1.a:1.b:1: Ara. MAYBE + Considered Problem: - Strict TRS: main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Ara {minDegree = 1, maxDegree = 3, araTimeout = 15, araRuleShifting = Just 1, isBestCase = True, mkCompletelyDefined = False, verboseOutput = False} + Details: Signatures used: ---------------- F (TrsFun "Nil") :: [] -(0)-> "A"(0, 0, 0) F (TrsFun "foldl#3") :: ["A"(0, 0, 0) x "A"(0, 0, 1)] -(0)-> "A"(0, 0, 0) F (TrsFun "main") :: ["A"(0, 0, 1)] -(1)-> "A"(0, 0, 0) Cost-free Signatures used: -------------------------- Base Constructor Signatures used: --------------------------------- Following Still Strict Rules were Typed as: ------------------------------------------- 1. Strict: main(x1) -> foldl#3(Nil(),x1) 2. Weak: *** Step 1.a:1.b:1: DecreasingLoops. WORST_CASE(Omega(n^1),?) + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: DecreasingLoops {bound = AnyLoop, narrow = 10} + Details: The system has following decreasing Loops: foldl#3(x,z){z -> Cons(y,z)} = foldl#3(x,Cons(y,z)) ->^+ foldl#3(Cons(y,x),z) = C[foldl#3(Cons(y,x),z) = foldl#3(x,z){x -> Cons(y,x)}] ** Step 1.b:1: Bounds. WORST_CASE(?,O(n^1)) + Considered Problem: - Strict TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: Bounds {initialAutomaton = minimal, enrichment = match} + Details: The problem is match-bounded by 1. The enriched problem is compatible with follwoing automaton. Cons_0(2,2) -> 1 Cons_0(2,2) -> 2 Cons_1(2,2) -> 1 Cons_1(2,2) -> 3 Cons_1(2,3) -> 1 Cons_1(2,3) -> 3 Nil_0() -> 1 Nil_0() -> 2 Nil_1() -> 1 Nil_1() -> 3 foldl#3_0(2,2) -> 1 foldl#3_1(3,2) -> 1 main_0(2) -> 1 2 -> 1 3 -> 1 ** Step 1.b:2: EmptyProcessor. WORST_CASE(?,O(1)) + Considered Problem: - Weak TRS: foldl#3(x16,Cons(x24,x6)) -> foldl#3(Cons(x24,x16),x6) foldl#3(x2,Nil()) -> x2 main(x1) -> foldl#3(Nil(),x1) - Signature: {foldl#3/2,main/1} / {Cons/2,Nil/0} - Obligation: innermost runtime complexity wrt. defined symbols {foldl#3,main} and constructors {Cons,Nil} + Applied Processor: EmptyProcessor + Details: The problem is already closed. The intended complexity is O(1). WORST_CASE(Omega(n^1),O(n^1))