/export/starexec/sandbox2/solver/bin/starexec_run_rcdcRelativeAlsoLower /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- WORST_CASE(Omega(n^1), O(n^1)) proof of /export/starexec/sandbox2/benchmark/theBenchmark.xml # AProVE Commit ID: 794c25de1cacf0d048858bcd21c9a779e1221865 marcel 20200619 unpublished dirty The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(n^1, n^1). (0) DCpxTrs (1) DerivationalComplexityToRuntimeComplexityProof [BOTH BOUNDS(ID, ID), 0 ms] (2) CpxRelTRS (3) SInnermostTerminationProof [BOTH CONCRETE BOUNDS(ID, ID), 162 ms] (4) CpxRelTRS (5) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (6) CpxTRS (7) CpxTrsMatchBoundsTAProof [FINISHED, 79 ms] (8) BOUNDS(1, n^1) (9) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (10) TRS for Loop Detection (11) DecreasingLoopProof [LOWER BOUND(ID), 0 ms] (12) BEST (13) proven lower bound (14) LowerBoundPropagationProof [FINISHED, 0 ms] (15) BOUNDS(n^1, INF) (16) TRS for Loop Detection ---------------------------------------- (0) Obligation: The Derivational Complexity (innermost) of the given DCpxTrs could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (1) DerivationalComplexityToRuntimeComplexityProof (BOTH BOUNDS(ID, ID)) The following rules have been added to S to convert the given derivational complexity problem to a runtime complexity problem: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 ---------------------------------------- (2) Obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m The (relative) TRS S consists of the following rules: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 Rewrite Strategy: INNERMOST ---------------------------------------- (3) SInnermostTerminationProof (BOTH CONCRETE BOUNDS(ID, ID)) proved innermost termination of relative rules ---------------------------------------- (4) Obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m The (relative) TRS S consists of the following rules: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 Rewrite Strategy: INNERMOST ---------------------------------------- (5) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (6) Obligation: The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 S is empty. Rewrite Strategy: INNERMOST ---------------------------------------- (7) CpxTrsMatchBoundsTAProof (FINISHED) A linear upper bound on the runtime complexity of the TRS R could be shown with a Match-Bound[TAB_LEFTLINEAR,TAB_NONLEFTLINEAR] (for contructor-based start-terms) of 2. The compatible tree automaton used to show the Match-Boundedness (for constructor-based start-terms) is represented by: final states : [1, 2, 3, 4, 5] transitions: s0(0) -> 0 00() -> 0 cons_p0(0, 0, 0) -> 0 p0(0, 0, 0) -> 1 encArg0(0) -> 2 encode_p0(0, 0, 0) -> 3 encode_s0(0) -> 4 encode_00() -> 5 p1(0, 0, 0) -> 1 01() -> 6 p1(6, 0, 0) -> 1 encArg1(0) -> 7 s1(7) -> 2 01() -> 2 encArg1(0) -> 8 encArg1(0) -> 9 encArg1(0) -> 10 p1(8, 9, 10) -> 2 p1(8, 9, 10) -> 3 s1(7) -> 4 01() -> 5 p1(6, 0, 6) -> 1 s1(7) -> 7 s1(7) -> 8 s1(7) -> 9 s1(7) -> 10 01() -> 7 01() -> 8 01() -> 9 01() -> 10 p1(8, 9, 10) -> 7 p1(8, 9, 10) -> 8 p1(8, 9, 10) -> 9 p1(8, 9, 10) -> 10 p2(8, 7, 9) -> 2 p2(8, 7, 9) -> 3 p2(8, 7, 9) -> 7 p2(8, 7, 9) -> 8 p2(8, 7, 9) -> 9 p2(8, 7, 9) -> 10 02() -> 11 p2(11, 7, 8) -> 2 p2(11, 7, 8) -> 3 p2(11, 7, 8) -> 7 p2(11, 7, 8) -> 8 p2(11, 7, 8) -> 9 p2(11, 7, 8) -> 10 p2(8, 7, 7) -> 2 p2(11, 7, 7) -> 2 p2(8, 7, 7) -> 3 p2(11, 7, 7) -> 3 p2(8, 7, 7) -> 7 p2(11, 7, 7) -> 7 p2(8, 7, 7) -> 8 p2(11, 7, 7) -> 8 p2(11, 7, 11) -> 2 p2(11, 7, 11) -> 3 p2(11, 7, 11) -> 7 p2(11, 7, 11) -> 8 0 -> 1 6 -> 1 8 -> 2 8 -> 3 8 -> 7 8 -> 9 8 -> 10 11 -> 2 11 -> 3 11 -> 7 11 -> 8 ---------------------------------------- (8) BOUNDS(1, n^1) ---------------------------------------- (9) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (10) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m The (relative) TRS S consists of the following rules: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 Rewrite Strategy: INNERMOST ---------------------------------------- (11) DecreasingLoopProof (LOWER BOUND(ID)) The following loop(s) give(s) rise to the lower bound Omega(n^1): The rewrite sequence p(m, s(r3_0), s(r)) ->^+ p(m, r3_0, r) gives rise to a decreasing loop by considering the right hand sides subterm at position []. The pumping substitution is [r3_0 / s(r3_0), r / s(r)]. The result substitution is [ ]. ---------------------------------------- (12) Complex Obligation (BEST) ---------------------------------------- (13) Obligation: Proved the lower bound n^1 for the following obligation: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m The (relative) TRS S consists of the following rules: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 Rewrite Strategy: INNERMOST ---------------------------------------- (14) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (15) BOUNDS(n^1, INF) ---------------------------------------- (16) Obligation: Analyzing the following TRS for decreasing loops: The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: p(m, n, s(r)) -> p(m, r, n) p(m, s(n), 0) -> p(0, n, m) p(m, 0, 0) -> m The (relative) TRS S consists of the following rules: encArg(s(x_1)) -> s(encArg(x_1)) encArg(0) -> 0 encArg(cons_p(x_1, x_2, x_3)) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_p(x_1, x_2, x_3) -> p(encArg(x_1), encArg(x_2), encArg(x_3)) encode_s(x_1) -> s(encArg(x_1)) encode_0 -> 0 Rewrite Strategy: INNERMOST