/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) NestedDefinedSymbolProof [UPPER BOUND(ID), 0 ms] (2) CpxTRS (3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms] (4) CpxTRS (5) CpxTrsMatchBoundsTAProof [FINISHED, 319 ms] (6) BOUNDS(1, n^1) (7) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms] (8) CpxTRS (9) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms] (10) typed CpxTrs (11) OrderProof [LOWER BOUND(ID), 0 ms] (12) typed CpxTrs (13) RewriteLemmaProof [LOWER BOUND(ID), 419 ms] (14) BEST (15) proven lower bound (16) LowerBoundPropagationProof [FINISHED, 0 ms] (17) BOUNDS(n^1, INF) (18) typed CpxTrs (19) RewriteLemmaProof [LOWER BOUND(ID), 118 ms] (20) typed CpxTrs (21) RewriteLemmaProof [LOWER BOUND(ID), 87 ms] (22) typed CpxTrs (23) RewriteLemmaProof [LOWER BOUND(ID), 75 ms] (24) typed CpxTrs (25) RewriteLemmaProof [LOWER BOUND(ID), 142 ms] (26) typed CpxTrs (27) RewriteLemmaProof [LOWER BOUND(ID), 93 ms] (28) typed CpxTrs (29) RewriteLemmaProof [LOWER BOUND(ID), 37 ms] (30) typed CpxTrs (31) RewriteLemmaProof [LOWER BOUND(ID), 148 ms] (32) typed CpxTrs (33) RewriteLemmaProof [LOWER BOUND(ID), 72 ms] (34) typed CpxTrs (35) RewriteLemmaProof [LOWER BOUND(ID), 84 ms] (36) typed CpxTrs (37) RewriteLemmaProof [LOWER BOUND(ID), 117 ms] (38) typed CpxTrs (39) RewriteLemmaProof [LOWER BOUND(ID), 146 ms] (40) typed CpxTrs (41) RewriteLemmaProof [LOWER BOUND(ID), 134 ms] (42) typed CpxTrs ---------------------------------------- (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: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0, XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0) -> ok(0) proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) S is empty. Rewrite Strategy: FULL ---------------------------------------- (1) NestedDefinedSymbolProof (UPPER BOUND(ID)) The following defined symbols can occur below the 0th argument of top: proper, active The following defined symbols can occur below the 0th argument of proper: proper, active The following defined symbols can occur below the 0th argument of active: proper, active Hence, the left-hand sides of the following rules are not basic-reachable and can be removed: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0, XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) ---------------------------------------- (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: natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(0) -> ok(0) proper(nil) -> ok(nil) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) S is empty. Rewrite Strategy: FULL ---------------------------------------- (3) RelTrsToTrsProof (UPPER BOUND(ID)) transformed relative TRS to TRS ---------------------------------------- (4) 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: natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(0) -> ok(0) proper(nil) -> ok(nil) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) S is empty. Rewrite Strategy: FULL ---------------------------------------- (5) 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, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] transitions: mark0(0) -> 0 00() -> 0 ok0(0) -> 0 nil0() -> 0 active0(0) -> 0 natsFrom0(0) -> 1 cons0(0, 0) -> 2 s0(0) -> 3 fst0(0) -> 4 pair0(0, 0) -> 5 snd0(0) -> 6 splitAt0(0, 0) -> 7 u0(0, 0, 0, 0) -> 8 head0(0) -> 9 tail0(0) -> 10 sel0(0, 0) -> 11 afterNth0(0, 0) -> 12 take0(0, 0) -> 13 proper0(0) -> 14 top0(0) -> 15 natsFrom1(0) -> 16 mark1(16) -> 1 cons1(0, 0) -> 17 mark1(17) -> 2 s1(0) -> 18 mark1(18) -> 3 fst1(0) -> 19 mark1(19) -> 4 pair1(0, 0) -> 20 mark1(20) -> 5 snd1(0) -> 21 mark1(21) -> 6 splitAt1(0, 0) -> 22 mark1(22) -> 7 u1(0, 0, 0, 0) -> 23 mark1(23) -> 8 head1(0) -> 24 mark1(24) -> 9 tail1(0) -> 25 mark1(25) -> 10 sel1(0, 0) -> 26 mark1(26) -> 11 afterNth1(0, 0) -> 27 mark1(27) -> 12 take1(0, 0) -> 28 mark1(28) -> 13 01() -> 29 ok1(29) -> 14 nil1() -> 30 ok1(30) -> 14 natsFrom1(0) -> 31 ok1(31) -> 1 cons1(0, 0) -> 32 ok1(32) -> 2 s1(0) -> 33 ok1(33) -> 3 fst1(0) -> 34 ok1(34) -> 4 pair1(0, 0) -> 35 ok1(35) -> 5 snd1(0) -> 36 ok1(36) -> 6 splitAt1(0, 0) -> 37 ok1(37) -> 7 u1(0, 0, 0, 0) -> 38 ok1(38) -> 8 head1(0) -> 39 ok1(39) -> 9 tail1(0) -> 40 ok1(40) -> 10 sel1(0, 0) -> 41 ok1(41) -> 11 afterNth1(0, 0) -> 42 ok1(42) -> 12 take1(0, 0) -> 43 ok1(43) -> 13 proper1(0) -> 44 top1(44) -> 15 active1(0) -> 45 top1(45) -> 15 mark1(16) -> 16 mark1(16) -> 31 mark1(17) -> 17 mark1(17) -> 32 mark1(18) -> 18 mark1(18) -> 33 mark1(19) -> 19 mark1(19) -> 34 mark1(20) -> 20 mark1(20) -> 35 mark1(21) -> 21 mark1(21) -> 36 mark1(22) -> 22 mark1(22) -> 37 mark1(23) -> 23 mark1(23) -> 38 mark1(24) -> 24 mark1(24) -> 39 mark1(25) -> 25 mark1(25) -> 40 mark1(26) -> 26 mark1(26) -> 41 mark1(27) -> 27 mark1(27) -> 42 mark1(28) -> 28 mark1(28) -> 43 ok1(29) -> 44 ok1(30) -> 44 ok1(31) -> 16 ok1(31) -> 31 ok1(32) -> 17 ok1(32) -> 32 ok1(33) -> 18 ok1(33) -> 33 ok1(34) -> 19 ok1(34) -> 34 ok1(35) -> 20 ok1(35) -> 35 ok1(36) -> 21 ok1(36) -> 36 ok1(37) -> 22 ok1(37) -> 37 ok1(38) -> 23 ok1(38) -> 38 ok1(39) -> 24 ok1(39) -> 39 ok1(40) -> 25 ok1(40) -> 40 ok1(41) -> 26 ok1(41) -> 41 ok1(42) -> 27 ok1(42) -> 42 ok1(43) -> 28 ok1(43) -> 43 active2(29) -> 46 top2(46) -> 15 active2(30) -> 46 ---------------------------------------- (6) BOUNDS(1, n^1) ---------------------------------------- (7) RenamingProof (BOTH BOUNDS(ID, ID)) Renamed function symbols to avoid clashes with predefined symbol. ---------------------------------------- (8) Obligation: The Runtime Complexity (full) of the given CpxTRS could be proven to be BOUNDS(n^1, INF). The TRS R consists of the following rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) S is empty. Rewrite Strategy: FULL ---------------------------------------- (9) TypeInferenceProof (BOTH BOUNDS(ID, ID)) Infered types. ---------------------------------------- (10) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok ---------------------------------------- (11) OrderProof (LOWER BOUND(ID)) Heuristically decided to analyse the following defined symbols: active, cons, natsFrom, s, pair, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: cons < active natsFrom < active s < active pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top cons < proper natsFrom < proper s < proper pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (12) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: cons, active, natsFrom, s, pair, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: cons < active natsFrom < active s < active pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top cons < proper natsFrom < proper s < proper pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (13) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) Induction Base: cons(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: cons(gen_mark:0':nil:ok3_0(+(1, +(n5_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (14) Complex Obligation (BEST) ---------------------------------------- (15) Obligation: Proved the lower bound n^1 for the following obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: cons, active, natsFrom, s, pair, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: cons < active natsFrom < active s < active pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top cons < proper natsFrom < proper s < proper pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (16) LowerBoundPropagationProof (FINISHED) Propagated lower bound. ---------------------------------------- (17) BOUNDS(n^1, INF) ---------------------------------------- (18) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: natsFrom, active, s, pair, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: natsFrom < active s < active pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top natsFrom < proper s < proper pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (19) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) Induction Base: natsFrom(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: natsFrom(gen_mark:0':nil:ok3_0(+(1, +(n1518_0, 1)))) ->_R^Omega(1) mark(natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (20) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: s, active, pair, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: s < active pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top s < proper pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (21) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) Induction Base: s(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: s(gen_mark:0':nil:ok3_0(+(1, +(n2166_0, 1)))) ->_R^Omega(1) mark(s(gen_mark:0':nil:ok3_0(+(1, n2166_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (22) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: pair, active, u, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: pair < active u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top pair < proper u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (23) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) Induction Base: pair(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: pair(gen_mark:0':nil:ok3_0(+(1, +(n2915_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (24) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: u, active, splitAt, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: u < active splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top u < proper splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (25) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) Induction Base: u(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) Induction Step: u(gen_mark:0':nil:ok3_0(+(1, +(n5349_0, 1))), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) ->_R^Omega(1) mark(u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (26) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: splitAt, active, head, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: splitAt < active head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top splitAt < proper head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (27) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) Induction Base: splitAt(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: splitAt(gen_mark:0':nil:ok3_0(+(1, +(n10972_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (28) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: head, active, afterNth, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: head < active afterNth < active fst < active snd < active tail < active sel < active take < active active < top head < proper afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (29) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) Induction Base: head(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: head(gen_mark:0':nil:ok3_0(+(1, +(n14214_0, 1)))) ->_R^Omega(1) mark(head(gen_mark:0':nil:ok3_0(+(1, n14214_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (30) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: afterNth, active, fst, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: afterNth < active fst < active snd < active tail < active sel < active take < active active < top afterNth < proper fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (31) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) Induction Base: afterNth(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: afterNth(gen_mark:0':nil:ok3_0(+(1, +(n15612_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (32) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: fst, active, snd, tail, sel, take, proper, top They will be analysed ascendingly in the following order: fst < active snd < active tail < active sel < active take < active active < top fst < proper snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (33) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) Induction Base: fst(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: fst(gen_mark:0':nil:ok3_0(+(1, +(n19368_0, 1)))) ->_R^Omega(1) mark(fst(gen_mark:0':nil:ok3_0(+(1, n19368_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (34) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: snd, active, tail, sel, take, proper, top They will be analysed ascendingly in the following order: snd < active tail < active sel < active take < active active < top snd < proper tail < proper sel < proper take < proper proper < top ---------------------------------------- (35) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: snd(gen_mark:0':nil:ok3_0(+(1, n21017_0))) -> *4_0, rt in Omega(n21017_0) Induction Base: snd(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: snd(gen_mark:0':nil:ok3_0(+(1, +(n21017_0, 1)))) ->_R^Omega(1) mark(snd(gen_mark:0':nil:ok3_0(+(1, n21017_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (36) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) snd(gen_mark:0':nil:ok3_0(+(1, n21017_0))) -> *4_0, rt in Omega(n21017_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: tail, active, sel, take, proper, top They will be analysed ascendingly in the following order: tail < active sel < active take < active active < top tail < proper sel < proper take < proper proper < top ---------------------------------------- (37) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: tail(gen_mark:0':nil:ok3_0(+(1, n22767_0))) -> *4_0, rt in Omega(n22767_0) Induction Base: tail(gen_mark:0':nil:ok3_0(+(1, 0))) Induction Step: tail(gen_mark:0':nil:ok3_0(+(1, +(n22767_0, 1)))) ->_R^Omega(1) mark(tail(gen_mark:0':nil:ok3_0(+(1, n22767_0)))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (38) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) snd(gen_mark:0':nil:ok3_0(+(1, n21017_0))) -> *4_0, rt in Omega(n21017_0) tail(gen_mark:0':nil:ok3_0(+(1, n22767_0))) -> *4_0, rt in Omega(n22767_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: sel, active, take, proper, top They will be analysed ascendingly in the following order: sel < active take < active active < top sel < proper take < proper proper < top ---------------------------------------- (39) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: sel(gen_mark:0':nil:ok3_0(+(1, n24618_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n24618_0) Induction Base: sel(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: sel(gen_mark:0':nil:ok3_0(+(1, +(n24618_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(sel(gen_mark:0':nil:ok3_0(+(1, n24618_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (40) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) snd(gen_mark:0':nil:ok3_0(+(1, n21017_0))) -> *4_0, rt in Omega(n21017_0) tail(gen_mark:0':nil:ok3_0(+(1, n22767_0))) -> *4_0, rt in Omega(n22767_0) sel(gen_mark:0':nil:ok3_0(+(1, n24618_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n24618_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: take, active, proper, top They will be analysed ascendingly in the following order: take < active active < top take < proper proper < top ---------------------------------------- (41) RewriteLemmaProof (LOWER BOUND(ID)) Proved the following rewrite lemma: take(gen_mark:0':nil:ok3_0(+(1, n29304_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n29304_0) Induction Base: take(gen_mark:0':nil:ok3_0(+(1, 0)), gen_mark:0':nil:ok3_0(b)) Induction Step: take(gen_mark:0':nil:ok3_0(+(1, +(n29304_0, 1))), gen_mark:0':nil:ok3_0(b)) ->_R^Omega(1) mark(take(gen_mark:0':nil:ok3_0(+(1, n29304_0)), gen_mark:0':nil:ok3_0(b))) ->_IH mark(*4_0) We have rt in Omega(n^1) and sz in O(n). Thus, we have irc_R in Omega(n). ---------------------------------------- (42) Obligation: TRS: Rules: active(natsFrom(N)) -> mark(cons(N, natsFrom(s(N)))) active(fst(pair(XS, YS))) -> mark(XS) active(snd(pair(XS, YS))) -> mark(YS) active(splitAt(0', XS)) -> mark(pair(nil, XS)) active(splitAt(s(N), cons(X, XS))) -> mark(u(splitAt(N, XS), N, X, XS)) active(u(pair(YS, ZS), N, X, XS)) -> mark(pair(cons(X, YS), ZS)) active(head(cons(N, XS))) -> mark(N) active(tail(cons(N, XS))) -> mark(XS) active(sel(N, XS)) -> mark(head(afterNth(N, XS))) active(take(N, XS)) -> mark(fst(splitAt(N, XS))) active(afterNth(N, XS)) -> mark(snd(splitAt(N, XS))) active(natsFrom(X)) -> natsFrom(active(X)) active(cons(X1, X2)) -> cons(active(X1), X2) active(s(X)) -> s(active(X)) active(fst(X)) -> fst(active(X)) active(pair(X1, X2)) -> pair(active(X1), X2) active(pair(X1, X2)) -> pair(X1, active(X2)) active(snd(X)) -> snd(active(X)) active(splitAt(X1, X2)) -> splitAt(active(X1), X2) active(splitAt(X1, X2)) -> splitAt(X1, active(X2)) active(u(X1, X2, X3, X4)) -> u(active(X1), X2, X3, X4) active(head(X)) -> head(active(X)) active(tail(X)) -> tail(active(X)) active(sel(X1, X2)) -> sel(active(X1), X2) active(sel(X1, X2)) -> sel(X1, active(X2)) active(afterNth(X1, X2)) -> afterNth(active(X1), X2) active(afterNth(X1, X2)) -> afterNth(X1, active(X2)) active(take(X1, X2)) -> take(active(X1), X2) active(take(X1, X2)) -> take(X1, active(X2)) natsFrom(mark(X)) -> mark(natsFrom(X)) cons(mark(X1), X2) -> mark(cons(X1, X2)) s(mark(X)) -> mark(s(X)) fst(mark(X)) -> mark(fst(X)) pair(mark(X1), X2) -> mark(pair(X1, X2)) pair(X1, mark(X2)) -> mark(pair(X1, X2)) snd(mark(X)) -> mark(snd(X)) splitAt(mark(X1), X2) -> mark(splitAt(X1, X2)) splitAt(X1, mark(X2)) -> mark(splitAt(X1, X2)) u(mark(X1), X2, X3, X4) -> mark(u(X1, X2, X3, X4)) head(mark(X)) -> mark(head(X)) tail(mark(X)) -> mark(tail(X)) sel(mark(X1), X2) -> mark(sel(X1, X2)) sel(X1, mark(X2)) -> mark(sel(X1, X2)) afterNth(mark(X1), X2) -> mark(afterNth(X1, X2)) afterNth(X1, mark(X2)) -> mark(afterNth(X1, X2)) take(mark(X1), X2) -> mark(take(X1, X2)) take(X1, mark(X2)) -> mark(take(X1, X2)) proper(natsFrom(X)) -> natsFrom(proper(X)) proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) proper(s(X)) -> s(proper(X)) proper(fst(X)) -> fst(proper(X)) proper(pair(X1, X2)) -> pair(proper(X1), proper(X2)) proper(snd(X)) -> snd(proper(X)) proper(splitAt(X1, X2)) -> splitAt(proper(X1), proper(X2)) proper(0') -> ok(0') proper(nil) -> ok(nil) proper(u(X1, X2, X3, X4)) -> u(proper(X1), proper(X2), proper(X3), proper(X4)) proper(head(X)) -> head(proper(X)) proper(tail(X)) -> tail(proper(X)) proper(sel(X1, X2)) -> sel(proper(X1), proper(X2)) proper(afterNth(X1, X2)) -> afterNth(proper(X1), proper(X2)) proper(take(X1, X2)) -> take(proper(X1), proper(X2)) natsFrom(ok(X)) -> ok(natsFrom(X)) cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) s(ok(X)) -> ok(s(X)) fst(ok(X)) -> ok(fst(X)) pair(ok(X1), ok(X2)) -> ok(pair(X1, X2)) snd(ok(X)) -> ok(snd(X)) splitAt(ok(X1), ok(X2)) -> ok(splitAt(X1, X2)) u(ok(X1), ok(X2), ok(X3), ok(X4)) -> ok(u(X1, X2, X3, X4)) head(ok(X)) -> ok(head(X)) tail(ok(X)) -> ok(tail(X)) sel(ok(X1), ok(X2)) -> ok(sel(X1, X2)) afterNth(ok(X1), ok(X2)) -> ok(afterNth(X1, X2)) take(ok(X1), ok(X2)) -> ok(take(X1, X2)) top(mark(X)) -> top(proper(X)) top(ok(X)) -> top(active(X)) Types: active :: mark:0':nil:ok -> mark:0':nil:ok natsFrom :: mark:0':nil:ok -> mark:0':nil:ok mark :: mark:0':nil:ok -> mark:0':nil:ok cons :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok s :: mark:0':nil:ok -> mark:0':nil:ok fst :: mark:0':nil:ok -> mark:0':nil:ok pair :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok snd :: mark:0':nil:ok -> mark:0':nil:ok splitAt :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok 0' :: mark:0':nil:ok nil :: mark:0':nil:ok u :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok head :: mark:0':nil:ok -> mark:0':nil:ok tail :: mark:0':nil:ok -> mark:0':nil:ok sel :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok afterNth :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok take :: mark:0':nil:ok -> mark:0':nil:ok -> mark:0':nil:ok proper :: mark:0':nil:ok -> mark:0':nil:ok ok :: mark:0':nil:ok -> mark:0':nil:ok top :: mark:0':nil:ok -> top hole_mark:0':nil:ok1_0 :: mark:0':nil:ok hole_top2_0 :: top gen_mark:0':nil:ok3_0 :: Nat -> mark:0':nil:ok Lemmas: cons(gen_mark:0':nil:ok3_0(+(1, n5_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n5_0) natsFrom(gen_mark:0':nil:ok3_0(+(1, n1518_0))) -> *4_0, rt in Omega(n1518_0) s(gen_mark:0':nil:ok3_0(+(1, n2166_0))) -> *4_0, rt in Omega(n2166_0) pair(gen_mark:0':nil:ok3_0(+(1, n2915_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n2915_0) u(gen_mark:0':nil:ok3_0(+(1, n5349_0)), gen_mark:0':nil:ok3_0(b), gen_mark:0':nil:ok3_0(c), gen_mark:0':nil:ok3_0(d)) -> *4_0, rt in Omega(n5349_0) splitAt(gen_mark:0':nil:ok3_0(+(1, n10972_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n10972_0) head(gen_mark:0':nil:ok3_0(+(1, n14214_0))) -> *4_0, rt in Omega(n14214_0) afterNth(gen_mark:0':nil:ok3_0(+(1, n15612_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n15612_0) fst(gen_mark:0':nil:ok3_0(+(1, n19368_0))) -> *4_0, rt in Omega(n19368_0) snd(gen_mark:0':nil:ok3_0(+(1, n21017_0))) -> *4_0, rt in Omega(n21017_0) tail(gen_mark:0':nil:ok3_0(+(1, n22767_0))) -> *4_0, rt in Omega(n22767_0) sel(gen_mark:0':nil:ok3_0(+(1, n24618_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n24618_0) take(gen_mark:0':nil:ok3_0(+(1, n29304_0)), gen_mark:0':nil:ok3_0(b)) -> *4_0, rt in Omega(n29304_0) Generator Equations: gen_mark:0':nil:ok3_0(0) <=> 0' gen_mark:0':nil:ok3_0(+(x, 1)) <=> mark(gen_mark:0':nil:ok3_0(x)) The following defined symbols remain to be analysed: active, proper, top They will be analysed ascendingly in the following order: active < top proper < top