/export/starexec/sandbox/solver/bin/starexec_run_complexity /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), O(n^2)) proof of /export/starexec/sandbox/benchmark/theBenchmark.xml # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(n^1, n^2). (0) CpxTRS (1) RcToIrcProof [BOTH BOUNDS(ID, ID), 0 ms] (2) CpxTRS (3) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms] (4) CdtProblem (5) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 2 ms] (6) CdtProblem (7) CdtUsableRulesProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CdtProblem (9) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (10) CdtProblem (11) CdtInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms] (12) CdtProblem (13) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 16 ms] (14) CdtProblem (15) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (16) CdtProblem (17) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 69 ms] (18) CdtProblem (19) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 56 ms] (20) CdtProblem (21) SIsEmptyProof [BOTH BOUNDS(ID, ID), 0 ms] (22) BOUNDS(1, 1) (23) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (24) TRS for Loop Detection (25) DecreasingLoopProof [LOWER BOUND(ID), 0 ms] (26) BEST (27) proven lower bound (28) LowerBoundPropagationProof [FINISHED, 0 ms] (29) BOUNDS(n^1, INF) (30) TRS for Loop Detection ---------------------------------------- (0) Obligation: The Runtime Complexity (full) 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: FULL ---------------------------------------- (1) RcToIrcProof (BOTH BOUNDS(ID, ID)) Converted rc-obligation to irc-obligation. As the TRS does not nest defined symbols, we have rc = irc. ---------------------------------------- (2) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(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 ---------------------------------------- (3) CpxTrsToCdtProof (UPPER BOUND(ID)) Converted Cpx (relative) TRS to CDT ---------------------------------------- (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, 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 ---------------------------------------- (5) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID)) Removed 1 trailing nodes: R(z0, z1, z2, nil) -> c ---------------------------------------- (6) 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 ---------------------------------------- (7) 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))) ---------------------------------------- (8) 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 ---------------------------------------- (9) 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)) ---------------------------------------- (10) 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 ---------------------------------------- (11) 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))) ---------------------------------------- (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)) 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 ---------------------------------------- (13) 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) = [1] POL(succ(x_1)) = [1] + x_1 POL(zero) = [1] ---------------------------------------- (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)) 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 ---------------------------------------- (15) 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)) ---------------------------------------- (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(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 ---------------------------------------- (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(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 ---------------------------------------- (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: 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 ---------------------------------------- (19) 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 ---------------------------------------- (20) 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 ---------------------------------------- (21) SIsEmptyProof (BOTH BOUNDS(ID, ID)) The set S is empty ---------------------------------------- (22) BOUNDS(1, 1) ---------------------------------------- (23) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (24) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (full) 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: FULL ---------------------------------------- (25) 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)]. ---------------------------------------- (26) Complex Obligation (BEST) ---------------------------------------- (27) Obligation: Proved the lower bound n^1 for the following obligation: The Runtime Complexity (full) 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: FULL ---------------------------------------- (28) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (29) BOUNDS(n^1, INF) ---------------------------------------- (30) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (full) 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: FULL