/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, 136 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: a__f(0) -> cons(0, f(s(0))) a__f(s(0)) -> a__f(a__p(s(0))) a__p(s(0)) -> 0 mark(f(X)) -> a__f(mark(X)) mark(p(X)) -> a__p(mark(X)) mark(0) -> 0 mark(cons(X1, X2)) -> cons(mark(X1), X2) mark(s(X)) -> s(mark(X)) a__f(X) -> f(X) a__p(X) -> p(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: a__f(0) -> cons(0, f(s(0))) a__f(s(0)) -> a__f(a__p(s(0))) a__p(s(0)) -> 0 mark(f(X)) -> a__f(mark(X)) mark(p(X)) -> a__p(mark(X)) mark(0) -> 0 mark(cons(X1, X2)) -> cons(mark(X1), X2) mark(s(X)) -> s(mark(X)) a__f(X) -> f(X) a__p(X) -> p(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 3. The compatible tree automaton used to show the Match-Boundedness (for constructor-based start-terms) is represented by: final states : [1, 2, 3] transitions: 00() -> 0 cons0(0, 0) -> 0 f0(0) -> 0 s0(0) -> 0 p0(0) -> 0 a__f0(0) -> 1 a__p0(0) -> 2 mark0(0) -> 3 01() -> 4 01() -> 7 s1(7) -> 6 f1(6) -> 5 cons1(4, 5) -> 1 s1(7) -> 9 a__p1(9) -> 8 a__f1(8) -> 1 01() -> 2 mark1(0) -> 10 a__f1(10) -> 3 mark1(0) -> 11 a__p1(11) -> 3 01() -> 3 mark1(0) -> 12 cons1(12, 0) -> 3 mark1(0) -> 13 s1(13) -> 3 f1(0) -> 1 p1(0) -> 2 02() -> 8 a__f1(10) -> 10 a__f1(10) -> 11 a__f1(10) -> 12 a__f1(10) -> 13 a__p1(11) -> 10 a__p1(11) -> 11 a__p1(11) -> 12 a__p1(11) -> 13 01() -> 10 01() -> 11 01() -> 12 01() -> 13 cons1(12, 0) -> 10 cons1(12, 0) -> 11 cons1(12, 0) -> 12 cons1(12, 0) -> 13 s1(13) -> 10 s1(13) -> 11 s1(13) -> 12 s1(13) -> 13 f2(8) -> 1 f2(10) -> 3 p2(11) -> 3 p2(9) -> 8 02() -> 14 02() -> 17 s2(17) -> 16 f2(16) -> 15 cons2(14, 15) -> 3 cons2(14, 15) -> 10 cons2(14, 15) -> 11 cons2(14, 15) -> 12 cons2(14, 15) -> 13 s2(17) -> 19 a__p2(19) -> 18 a__f2(18) -> 3 a__f2(18) -> 10 a__f2(18) -> 11 a__f2(18) -> 12 a__f2(18) -> 13 02() -> 3 02() -> 10 02() -> 11 02() -> 12 02() -> 13 f2(10) -> 10 f2(10) -> 11 f2(10) -> 12 f2(10) -> 13 p2(11) -> 10 p2(11) -> 11 p2(11) -> 12 p2(11) -> 13 cons2(14, 15) -> 1 03() -> 18 f3(18) -> 3 f3(18) -> 10 f3(18) -> 11 f3(18) -> 12 f3(18) -> 13 p3(19) -> 18 03() -> 20 03() -> 23 s3(23) -> 22 f3(22) -> 21 cons3(20, 21) -> 3 cons3(20, 21) -> 10 cons3(20, 21) -> 11 cons3(20, 21) -> 12 cons3(20, 21) -> 13 ---------------------------------------- (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: a__f(0) -> cons(0, f(s(0))) a__f(s(0)) -> a__f(a__p(s(0))) a__p(s(0)) -> 0 mark(f(X)) -> a__f(mark(X)) mark(p(X)) -> a__p(mark(X)) mark(0) -> 0 mark(cons(X1, X2)) -> cons(mark(X1), X2) mark(s(X)) -> s(mark(X)) a__f(X) -> f(X) a__p(X) -> p(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 mark(f(X)) ->^+ a__f(mark(X)) gives rise to a decreasing loop by considering the right hand sides subterm at position [0]. The pumping substitution is [X / 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: a__f(0) -> cons(0, f(s(0))) a__f(s(0)) -> a__f(a__p(s(0))) a__p(s(0)) -> 0 mark(f(X)) -> a__f(mark(X)) mark(p(X)) -> a__p(mark(X)) mark(0) -> 0 mark(cons(X1, X2)) -> cons(mark(X1), X2) mark(s(X)) -> s(mark(X)) a__f(X) -> f(X) a__p(X) -> p(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: a__f(0) -> cons(0, f(s(0))) a__f(s(0)) -> a__f(a__p(s(0))) a__p(s(0)) -> 0 mark(f(X)) -> a__f(mark(X)) mark(p(X)) -> a__p(mark(X)) mark(0) -> 0 mark(cons(X1, X2)) -> cons(mark(X1), X2) mark(s(X)) -> s(mark(X)) a__f(X) -> f(X) a__p(X) -> p(X) S is empty. Rewrite Strategy: FULL