/export/starexec/sandbox2/solver/bin/starexec_run_complexity /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), O(n^2)) proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 48fb2092695e11cc9f56e44b17a92a5f88ffb256 marcel 20180622 unpublished dirty The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). (0) CpxTRS (1) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (2) CdtProblem (3) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms] (4) CdtProblem (5) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (6) CdtProblem (7) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CdtProblem (9) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (10) CdtProblem (11) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 20 ms] (12) CdtProblem (13) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (14) CdtProblem (15) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 45 ms] (16) CdtProblem (17) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 40 ms] (18) CdtProblem (19) SIsEmptyProof [BOTH BOUNDS(ID, ID), 0 ms] (20) BOUNDS(1, 1) (21) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (22) TRS for Loop Detection (23) DecreasingLoopProof [LOWER BOUND(ID), 0 ms] (24) BEST (25) proven lower bound (26) LowerBoundPropagationProof [FINISHED, 0 ms] (27) BOUNDS(n^1, INF) (28) TRS for Loop Detection ---------------------------------------- (0) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). The TRS R consists of the following rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(w, ws)) -> r(xs, xs, cons(succ(zero), zs), ws) r(xs, cons(y, ys), nil, cons(w, ws)) -> r(xs, xs, cons(succ(zero), nil), ws) r(xs, cons(y, ys), cons(z, zs), cons(w, ws)) -> r(ys, cons(y, ys), zs, cons(succ(zero), cons(w, ws))) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (1) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS to CDT ---------------------------------------- (2) Obligation: Complexity Dependency Tuples Problem Rules: r(z0, z1, z2, nil) -> z0 r(z0, nil, z1, cons(z2, z3)) -> r(z0, z0, cons(succ(zero), z1), z3) r(z0, cons(z1, z2), nil, cons(z3, z4)) -> r(z0, z0, cons(succ(zero), nil), z4) r(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> r(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6))) Tuples: R(z0, z1, z2, nil) -> c R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) S tuples: R(z0, z1, z2, nil) -> c R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) K tuples:none Defined Rule Symbols: r_4 Defined Pair Symbols: R_4 Compound Symbols: c, c1_1, c2_1, c3_1 ---------------------------------------- (3) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: R(z0, z1, z2, nil) -> c ---------------------------------------- (4) Obligation: Complexity Dependency Tuples Problem Rules: r(z0, z1, z2, nil) -> z0 r(z0, nil, z1, cons(z2, z3)) -> r(z0, z0, cons(succ(zero), z1), z3) r(z0, cons(z1, z2), nil, cons(z3, z4)) -> r(z0, z0, cons(succ(zero), nil), z4) r(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> r(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6))) Tuples: R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) S tuples: R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) K tuples:none Defined Rule Symbols: r_4 Defined Pair Symbols: R_4 Compound Symbols: c1_1, c2_1, c3_1 ---------------------------------------- (5) CdtUsableRulesProof (BOTH BOUNDS(ID, ID)) The following rules are not usable and were removed: r(z0, z1, z2, nil) -> z0 r(z0, nil, z1, cons(z2, z3)) -> r(z0, z0, cons(succ(zero), z1), z3) r(z0, cons(z1, z2), nil, cons(z3, z4)) -> r(z0, z0, cons(succ(zero), nil), z4) r(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> r(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6))) ---------------------------------------- (6) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) S tuples: R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) K tuples:none Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c1_1, c2_1, c3_1 ---------------------------------------- (7) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace R(z0, nil, z1, cons(z2, z3)) -> c1(R(z0, z0, cons(succ(zero), z1), z3)) by R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) ---------------------------------------- (8) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) S tuples: R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) K tuples:none Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c2_1, c3_1, c1_1 ---------------------------------------- (9) CdtInstantiationProof (BOTH BOUNDS(ID, ID)) Use instantiation to replace R(z0, cons(z1, z2), nil, cons(z3, z4)) -> c2(R(z0, z0, cons(succ(zero), nil), z4)) by R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) ---------------------------------------- (10) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) S tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) K tuples:none Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c3_1, c1_1, c2_1 ---------------------------------------- (11) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) We considered the (Usable) Rules:none And the Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) The order we found is given by the following interpretation: Polynomial interpretation : POL(R(x_1, x_2, x_3, x_4)) = x_2 POL(c1(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] + x_2 POL(nil) = [3] POL(succ(x_1)) = x_1 POL(zero) = 0 ---------------------------------------- (12) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) S tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) K tuples: R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c3_1, c1_1, c2_1 ---------------------------------------- (13) CdtKnowledgeProof (BOTH BOUNDS(ID, ID)) The following tuples could be moved from S to K by knowledge propagation: R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) ---------------------------------------- (14) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) S tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) K tuples: R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c3_1, c1_1, c2_1 ---------------------------------------- (15) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) We considered the (Usable) Rules:none And the Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) The order we found is given by the following interpretation: Polynomial interpretation : POL(R(x_1, x_2, x_3, x_4)) = x_2*x_3 + x_2^2 POL(c1(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] + x_2 POL(nil) = 0 POL(succ(x_1)) = 0 POL(zero) = 0 ---------------------------------------- (16) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) S tuples: R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) K tuples: R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c3_1, c1_1, c2_1 ---------------------------------------- (17) CdtRuleRemovalProof (UPPER BOUND(ADD(n^2))) Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S. R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) We considered the (Usable) Rules:none And the Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) The order we found is given by the following interpretation: Polynomial interpretation : POL(R(x_1, x_2, x_3, x_4)) = [2]x_2 + x_4 + [2]x_2*x_3 + x_2^2 POL(c1(x_1)) = x_1 POL(c2(x_1)) = x_1 POL(c3(x_1)) = x_1 POL(cons(x_1, x_2)) = [1] + x_2 POL(nil) = 0 POL(succ(x_1)) = 0 POL(zero) = 0 ---------------------------------------- (18) Obligation: Complexity Dependency Tuples Problem Rules:none Tuples: R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) S tuples:none K tuples: R(x2, cons(x1, x2), nil, cons(succ(zero), cons(x5, x6))) -> c2(R(x2, x2, cons(succ(zero), nil), cons(x5, x6))) R(nil, nil, cons(succ(zero), nil), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), nil)), z3)) R(z0, cons(z1, z2), cons(z3, z4), cons(z5, z6)) -> c3(R(z2, cons(z1, z2), z4, cons(succ(zero), cons(z5, z6)))) R(nil, nil, cons(succ(zero), x1), cons(z2, z3)) -> c1(R(nil, nil, cons(succ(zero), cons(succ(zero), x1)), z3)) Defined Rule Symbols:none Defined Pair Symbols: R_4 Compound Symbols: c3_1, c1_1, c2_1 ---------------------------------------- (19) SIsEmptyProof (BOTH BOUNDS(ID, ID)) The set S is empty ---------------------------------------- (20) BOUNDS(1, 1) ---------------------------------------- (21) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (22) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). The TRS R consists of the following rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(w, ws)) -> r(xs, xs, cons(succ(zero), zs), ws) r(xs, cons(y, ys), nil, cons(w, ws)) -> r(xs, xs, cons(succ(zero), nil), ws) r(xs, cons(y, ys), cons(z, zs), cons(w, ws)) -> r(ys, cons(y, ys), zs, cons(succ(zero), cons(w, ws))) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (23) DecreasingLoopProof (LOWER BOUND(ID)) The following loop(s) give(s) rise to the lower bound Omega(n^1): The rewrite sequence r(xs, cons(y, ys), cons(z, zs), cons(w, ws)) ->^+ r(ys, cons(y, ys), zs, cons(succ(zero), cons(w, ws))) gives rise to a decreasing loop by considering the right hand sides subterm at position []. The pumping substitution is [zs / cons(z, zs)]. The result substitution is [xs / ys, w / succ(zero), ws / cons(w, ws)]. ---------------------------------------- (24) Complex Obligation (BEST) ---------------------------------------- (25) Obligation: Proved the lower bound n^1 for the following obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). The TRS R consists of the following rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(w, ws)) -> r(xs, xs, cons(succ(zero), zs), ws) r(xs, cons(y, ys), nil, cons(w, ws)) -> r(xs, xs, cons(succ(zero), nil), ws) r(xs, cons(y, ys), cons(z, zs), cons(w, ws)) -> r(ys, cons(y, ys), zs, cons(succ(zero), cons(w, ws))) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (26) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (27) BOUNDS(n^1, INF) ---------------------------------------- (28) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). The TRS R consists of the following rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(w, ws)) -> r(xs, xs, cons(succ(zero), zs), ws) r(xs, cons(y, ys), nil, cons(w, ws)) -> r(xs, xs, cons(succ(zero), nil), ws) r(xs, cons(y, ys), cons(z, zs), cons(w, ws)) -> r(ys, cons(y, ys), zs, cons(succ(zero), cons(w, ws))) S is empty. Rewrite Strategy: INNERMOST