/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 (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)), 222 ms] (12) CdtProblem (13) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms] (14) CdtProblem (15) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 40 ms] (16) CdtProblem (17) CdtRuleRemovalProof [UPPER BOUND(ADD(n^2)), 72 ms] (18) CdtProblem (19) SIsEmptyProof [BOTH BOUNDS(ID, ID), 0 ms] (20) BOUNDS(1, 1) (21) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (22) CpxTRS (23) SlicingProof [LOWER BOUND(ID), 0 ms] (24) CpxTRS (25) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (26) typed CpxTrs (27) OrderProof [LOWER BOUND(ID), 0 ms] (28) typed CpxTrs (29) RewriteLemmaProof [LOWER BOUND(ID), 365 ms] (30) proven lower bound (31) LowerBoundPropagationProof [FINISHED, 0 ms] (32) BOUNDS(n^1, INF) ---------------------------------------- (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) = 0 POL(succ(x_1)) = 0 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) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (22) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). 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) SlicingProof (LOWER BOUND(ID)) Sliced the following arguments: cons/0 succ/0 ---------------------------------------- (24) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(ws)) -> r(xs, xs, cons(zs), ws) r(xs, cons(ys), nil, cons(ws)) -> r(xs, xs, cons(nil), ws) r(xs, cons(ys), cons(zs), cons(ws)) -> r(ys, cons(ys), zs, cons(cons(ws))) S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (25) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (26) Obligation: Innermost TRS: Rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(ws)) -> r(xs, xs, cons(zs), ws) r(xs, cons(ys), nil, cons(ws)) -> r(xs, xs, cons(nil), ws) r(xs, cons(ys), cons(zs), cons(ws)) -> r(ys, cons(ys), zs, cons(cons(ws))) Types: r :: nil:cons -> nil:cons -> nil:cons -> nil:cons -> nil:cons nil :: nil:cons cons :: nil:cons -> nil:cons hole_nil:cons1_0 :: nil:cons gen_nil:cons2_0 :: Nat -> nil:cons ---------------------------------------- (27) OrderProof (LOWER BOUND(ID)) Heuristically decided to analyse the following defined symbols: r ---------------------------------------- (28) Obligation: Innermost TRS: Rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(ws)) -> r(xs, xs, cons(zs), ws) r(xs, cons(ys), nil, cons(ws)) -> r(xs, xs, cons(nil), ws) r(xs, cons(ys), cons(zs), cons(ws)) -> r(ys, cons(ys), zs, cons(cons(ws))) Types: r :: nil:cons -> nil:cons -> nil:cons -> nil:cons -> nil:cons nil :: nil:cons cons :: nil:cons -> nil:cons hole_nil:cons1_0 :: nil:cons gen_nil:cons2_0 :: Nat -> nil:cons Generator Equations: gen_nil:cons2_0(0) <=> nil gen_nil:cons2_0(+(x, 1)) <=> cons(gen_nil:cons2_0(x)) The following defined symbols remain to be analysed: r ---------------------------------------- (29) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: r(gen_nil:cons2_0(0), gen_nil:cons2_0(0), gen_nil:cons2_0(c), gen_nil:cons2_0(n4_0)) -> gen_nil:cons2_0(0), rt in Omega(1 + n4_0) Induction Base: r(gen_nil:cons2_0(0), gen_nil:cons2_0(0), gen_nil:cons2_0(c), gen_nil:cons2_0(0)) ->_R^Omega(1) gen_nil:cons2_0(0) Induction Step: r(gen_nil:cons2_0(0), gen_nil:cons2_0(0), gen_nil:cons2_0(c), gen_nil:cons2_0(+(n4_0, 1))) ->_R^Omega(1) r(gen_nil:cons2_0(0), gen_nil:cons2_0(0), cons(gen_nil:cons2_0(c)), gen_nil:cons2_0(n4_0)) ->_IH gen_nil:cons2_0(0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (30) Obligation: Proved the lower bound n^1 for the following obligation: Innermost TRS: Rules: r(xs, ys, zs, nil) -> xs r(xs, nil, zs, cons(ws)) -> r(xs, xs, cons(zs), ws) r(xs, cons(ys), nil, cons(ws)) -> r(xs, xs, cons(nil), ws) r(xs, cons(ys), cons(zs), cons(ws)) -> r(ys, cons(ys), zs, cons(cons(ws))) Types: r :: nil:cons -> nil:cons -> nil:cons -> nil:cons -> nil:cons nil :: nil:cons cons :: nil:cons -> nil:cons hole_nil:cons1_0 :: nil:cons gen_nil:cons2_0 :: Nat -> nil:cons Generator Equations: gen_nil:cons2_0(0) <=> nil gen_nil:cons2_0(+(x, 1)) <=> cons(gen_nil:cons2_0(x)) The following defined symbols remain to be analysed: r ---------------------------------------- (31) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (32) BOUNDS(n^1, INF)