/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^1)) 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^1). (0) CpxTRS (1) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (2) CpxTRS (3) CpxTrsMatchBoundsTAProof [FINISHED, 108 ms] (4) BOUNDS(1, n^1) (5) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms] (6) TRS for Loop Detection (7) DecreasingLoopProof [LOWER BOUND(ID), 0 ms] (8) BEST (9) proven lower bound (10) LowerBoundPropagationProof [FINISHED, 0 ms] (11) BOUNDS(n^1, INF) (12) TRS for Loop Detection ---------------------------------------- (0) Obligation: The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(n^1, n^1). The TRS R consists of the following rules: f(0) -> cons(0, n__f(n__s(n__0))) f(s(0)) -> f(p(s(0))) p(s(X)) -> X f(X) -> n__f(X) s(X) -> n__s(X) 0 -> n__0 activate(n__f(X)) -> f(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__0) -> 0 activate(X) -> X S is empty. Rewrite Strategy: FULL ---------------------------------------- (1) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (2) Obligation: The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(1, n^1). The TRS R consists of the following rules: f(0) -> cons(0, n__f(n__s(n__0))) f(s(0)) -> f(p(s(0))) p(s(X)) -> X f(X) -> n__f(X) s(X) -> n__s(X) 0 -> n__0 activate(n__f(X)) -> f(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__0) -> 0 activate(X) -> X S is empty. Rewrite Strategy: FULL ---------------------------------------- (3) 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 4. 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: cons0(0, 0) -> 0 n__f0(0) -> 0 n__s0(0) -> 0 n__00() -> 0 f0(0) -> 1 p0(0) -> 2 s0(0) -> 3 00() -> 4 activate0(0) -> 5 n__f1(0) -> 1 n__s1(0) -> 3 n__01() -> 4 activate1(0) -> 6 f1(6) -> 5 activate1(0) -> 7 s1(7) -> 5 01() -> 5 n__f2(6) -> 5 n__s2(7) -> 5 n__02() -> 5 f1(6) -> 6 f1(6) -> 7 s1(7) -> 6 s1(7) -> 7 01() -> 6 01() -> 7 n__f2(6) -> 6 n__f2(6) -> 7 n__s2(7) -> 6 n__s2(7) -> 7 n__02() -> 6 n__02() -> 7 02() -> 8 n__02() -> 11 n__s2(11) -> 10 n__f2(10) -> 9 cons2(8, 9) -> 5 cons2(8, 9) -> 6 cons2(8, 9) -> 7 02() -> 14 s2(14) -> 13 p2(13) -> 12 f2(12) -> 5 f2(12) -> 6 f2(12) -> 7 n__f3(12) -> 5 n__f3(12) -> 6 n__f3(12) -> 7 n__s3(14) -> 13 n__03() -> 8 n__03() -> 14 03() -> 15 n__03() -> 18 n__s3(18) -> 17 n__f3(17) -> 16 cons3(15, 16) -> 5 cons3(15, 16) -> 6 cons3(15, 16) -> 7 n__04() -> 15 0 -> 5 0 -> 6 0 -> 7 14 -> 12 ---------------------------------------- (4) BOUNDS(1, n^1) ---------------------------------------- (5) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID)) Transformed a relative TRS into a decreasing-loop problem. ---------------------------------------- (6) 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^1). The TRS R consists of the following rules: f(0) -> cons(0, n__f(n__s(n__0))) f(s(0)) -> f(p(s(0))) p(s(X)) -> X f(X) -> n__f(X) s(X) -> n__s(X) 0 -> n__0 activate(n__f(X)) -> f(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__0) -> 0 activate(X) -> X S is empty. Rewrite Strategy: FULL ---------------------------------------- (7) DecreasingLoopProof (LOWER BOUND(ID)) The following loop(s) give(s) rise to the lower bound Omega(n^1): The rewrite sequence activate(n__f(X)) ->^+ f(activate(X)) gives rise to a decreasing loop by considering the right hand sides subterm at position [0]. The pumping substitution is [X / n__f(X)]. The result substitution is [ ]. ---------------------------------------- (8) Complex Obligation (BEST) ---------------------------------------- (9) 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^1). The TRS R consists of the following rules: f(0) -> cons(0, n__f(n__s(n__0))) f(s(0)) -> f(p(s(0))) p(s(X)) -> X f(X) -> n__f(X) s(X) -> n__s(X) 0 -> n__0 activate(n__f(X)) -> f(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__0) -> 0 activate(X) -> X S is empty. Rewrite Strategy: FULL ---------------------------------------- (10) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (11) BOUNDS(n^1, INF) ---------------------------------------- (12) 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^1). The TRS R consists of the following rules: f(0) -> cons(0, n__f(n__s(n__0))) f(s(0)) -> f(p(s(0))) p(s(X)) -> X f(X) -> n__f(X) s(X) -> n__s(X) 0 -> n__0 activate(n__f(X)) -> f(activate(X)) activate(n__s(X)) -> s(activate(X)) activate(n__0) -> 0 activate(X) -> X S is empty. Rewrite Strategy: FULL