We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, splitAt(s(N), cons(X, XS)) -> U11(tt(), N, X, activate(XS))
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
Arguments of following rules are not normal-forms:
{ splitAt(s(N), cons(X, XS)) -> U11(tt(), N, X, activate(XS)) }
All above mentioned rules can be savely removed.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We add the following dependency tuples:
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, snd^#(pair(X, Y)) -> c_8()
, and^#(tt(), X) -> c_9(activate^#(X))
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11()
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
and mark the set of starting terms.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, snd^#(pair(X, Y)) -> c_8()
, and^#(tt(), X) -> c_9(activate^#(X))
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11()
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We estimate the number of application of {3,4,7,8,9,11,13,14} by
applications of Pre({3,4,7,8,9,11,13,14}) =
{1,2,5,6,10,12,15,16,17}. Here rules are labeled as follows:
DPs:
{ 1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 2: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, 3: splitAt^#(0(), XS) -> c_3()
, 4: activate^#(X) -> c_4()
, 5: activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, 6: activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, 7: natsFrom^#(N) -> c_12()
, 8: natsFrom^#(X) -> c_13()
, 9: s^#(X) -> c_15()
, 10: afterNth^#(N, XS) ->
c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, 11: snd^#(pair(X, Y)) -> c_8()
, 12: and^#(tt(), X) -> c_9(activate^#(X))
, 13: fst^#(pair(X, Y)) -> c_10()
, 14: head^#(cons(N, XS)) -> c_11()
, 15: sel^#(N, XS) ->
c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, 16: tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, 17: take^#(N, XS) ->
c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, and^#(tt(), X) -> c_9(activate^#(X))
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
Weak DPs:
{ splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, snd^#(pair(X, Y)) -> c_8()
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11() }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We estimate the number of application of {5,9} by applications of
Pre({5,9}) = {7}. Here rules are labeled as follows:
DPs:
{ 1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 2: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, 3: activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, 4: activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, 5: afterNth^#(N, XS) ->
c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, 6: and^#(tt(), X) -> c_9(activate^#(X))
, 7: sel^#(N, XS) ->
c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, 8: tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, 9: take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS))
, 10: splitAt^#(0(), XS) -> c_3()
, 11: activate^#(X) -> c_4()
, 12: natsFrom^#(N) -> c_12()
, 13: natsFrom^#(X) -> c_13()
, 14: s^#(X) -> c_15()
, 15: snd^#(pair(X, Y)) -> c_8()
, 16: fst^#(pair(X, Y)) -> c_10()
, 17: head^#(cons(N, XS)) -> c_11() }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, and^#(tt(), X) -> c_9(activate^#(X))
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS)) }
Weak DPs:
{ splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, snd^#(pair(X, Y)) -> c_8()
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11()
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We estimate the number of application of {6} by applications of
Pre({6}) = {}. Here rules are labeled as follows:
DPs:
{ 1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 2: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, 3: activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, 4: activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, 5: and^#(tt(), X) -> c_9(activate^#(X))
, 6: sel^#(N, XS) ->
c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, 7: tail^#(cons(N, XS)) -> c_16(activate^#(XS))
, 8: splitAt^#(0(), XS) -> c_3()
, 9: activate^#(X) -> c_4()
, 10: natsFrom^#(N) -> c_12()
, 11: natsFrom^#(X) -> c_13()
, 12: s^#(X) -> c_15()
, 13: afterNth^#(N, XS) ->
c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, 14: snd^#(pair(X, Y)) -> c_8()
, 15: fst^#(pair(X, Y)) -> c_10()
, 16: head^#(cons(N, XS)) -> c_11()
, 17: take^#(N, XS) ->
c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, and^#(tt(), X) -> c_9(activate^#(X))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS)) }
Weak DPs:
{ splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, snd^#(pair(X, Y)) -> c_8()
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11()
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ splitAt^#(0(), XS) -> c_3()
, activate^#(X) -> c_4()
, natsFrom^#(N) -> c_12()
, natsFrom^#(X) -> c_13()
, s^#(X) -> c_15()
, afterNth^#(N, XS) -> c_7(snd^#(splitAt(N, XS)), splitAt^#(N, XS))
, snd^#(pair(X, Y)) -> c_8()
, fst^#(pair(X, Y)) -> c_10()
, head^#(cons(N, XS)) -> c_11()
, sel^#(N, XS) -> c_14(head^#(afterNth(N, XS)), afterNth^#(N, XS))
, take^#(N, XS) -> c_17(fst^#(splitAt(N, XS)), splitAt^#(N, XS)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X))
, and^#(tt(), X) -> c_9(activate^#(X))
, tail^#(cons(N, XS)) -> c_16(activate^#(XS)) }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
splitAt^#(activate(N), activate(XS)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) ->
c_5(natsFrom^#(activate(X)), activate^#(X))
, activate^#(n__s(X)) -> c_6(s^#(activate(X)), activate^#(X)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X))
, and^#(tt(), X) -> c_5(activate^#(X))
, tail^#(cons(N, XS)) -> c_6(activate^#(XS)) }
Weak Trs:
{ U11(tt(), N, X, XS) ->
U12(splitAt(activate(N), activate(XS)), activate(X))
, U12(pair(YS, ZS), X) -> pair(cons(activate(X), YS), ZS)
, splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, afterNth(N, XS) -> snd(splitAt(N, XS))
, snd(pair(X, Y)) -> Y
, and(tt(), X) -> activate(X)
, fst(pair(X, Y)) -> X
, head(cons(N, XS)) -> N
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, sel(N, XS) -> head(afterNth(N, XS))
, s(X) -> n__s(X)
, tail(cons(N, XS)) -> activate(XS)
, take(N, XS) -> fst(splitAt(N, XS)) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We replace rewrite rules by usable rules:
Weak Usable Rules:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X))
, and^#(tt(), X) -> c_5(activate^#(X))
, tail^#(cons(N, XS)) -> c_6(activate^#(XS)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
Consider the dependency graph
1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
-->_4 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_3 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_2 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_4 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
-->_3 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
-->_2 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
-->_1 U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) :2
2: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
-->_1 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_1 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
3: activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
-->_1 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_1 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
4: activate^#(n__s(X)) -> c_4(activate^#(X))
-->_1 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_1 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
5: and^#(tt(), X) -> c_5(activate^#(X))
-->_1 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_1 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
6: tail^#(cons(N, XS)) -> c_6(activate^#(XS))
-->_1 activate^#(n__s(X)) -> c_4(activate^#(X)) :4
-->_1 activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) :3
Following roots of the dependency graph are removed, as the
considered set of starting terms is closed under reduction with
respect to these rules (modulo compound contexts).
{ and^#(tt(), X) -> c_5(activate^#(X))
, tail^#(cons(N, XS)) -> c_6(activate^#(XS)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We analyse the complexity of following sub-problems (R) and (S).
Problem (S) is obtained from the input problem by shifting strict
rules from (R) into the weak component:
Problem (R):
------------
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
StartTerms: basic terms
Strategy: innermost
Problem (S):
------------
Strict DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
StartTerms: basic terms
Strategy: innermost
Overall, the transformation results in the following sub-problem(s):
Generated new problems:
-----------------------
R) Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
StartTerms: basic terms
Strategy: innermost
This problem was proven YES(O(1),O(n^1)).
S) Strict DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
StartTerms: basic terms
Strategy: innermost
This problem was proven YES(O(1),O(1)).
Proofs for generated problems:
------------------------------
R) We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 2: activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) }
Trs: { natsFrom(N) -> cons(N, n__natsFrom(n__s(N))) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1, 2, 3, 4}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
Uargs(c_4) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[tt] = [0]
[splitAt](x1, x2) = [0]
[activate](x1) = [1] x1 + [0]
[pair](x1, x2) = [1] x1 + [0]
[cons](x1, x2) = [0]
[natsFrom](x1) = [1] x1 + [1]
[n__natsFrom](x1) = [1] x1 + [1]
[n__s](x1) = [1] x1 + [0]
[0] = [0]
[nil] = [0]
[s](x1) = [1] x1 + [0]
[U11^#](x1, x2, x3, x4) = [7] x2 + [7] x3 + [7] x4 + [7]
[U12^#](x1, x2) = [4] x2 + [0]
[activate^#](x1) = [1] x1 + [0]
[c_1](x1, x2, x3, x4) = [1] x1 + [4] x2 + [1] x3 + [1] x4 + [0]
[c_2](x1) = [4] x1 + [0]
[c_3](x1) = [1] x1 + [0]
[c_4](x1) = [1] x1 + [0]
The order satisfies the following ordering constraints:
[splitAt(0(), XS)] = [0]
>= [0]
= [pair(nil(), XS)]
[activate(X)] = [1] X + [0]
>= [1] X + [0]
= [X]
[activate(n__natsFrom(X))] = [1] X + [1]
>= [1] X + [1]
= [natsFrom(activate(X))]
[activate(n__s(X))] = [1] X + [0]
>= [1] X + [0]
= [s(activate(X))]
[natsFrom(N)] = [1] N + [1]
> [0]
= [cons(N, n__natsFrom(n__s(N)))]
[natsFrom(X)] = [1] X + [1]
>= [1] X + [1]
= [n__natsFrom(X)]
[s(X)] = [1] X + [0]
>= [1] X + [0]
= [n__s(X)]
[U11^#(tt(), N, X, XS)] = [7] N + [7] X + [7] XS + [7]
> [4] N + [5] X + [1] XS + [0]
= [c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))]
[U12^#(pair(YS, ZS), X)] = [4] X + [0]
>= [4] X + [0]
= [c_2(activate^#(X))]
[activate^#(n__natsFrom(X))] = [1] X + [1]
> [1] X + [0]
= [c_3(activate^#(X))]
[activate^#(n__s(X))] = [1] X + [0]
>= [1] X + [0]
= [c_4(activate^#(X))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 2: activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, 3: activate^#(n__s(X)) -> c_4(activate^#(X))
, 4: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {1,2}. These cover all (indirect) predecessors of dependency
pairs {1,2,4}, their number of application is equally bounded. The
dependency pairs are shifted into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^1)).
Strict DPs: { activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(n^1))
We use the processor 'matrix interpretation of dimension 1' to
orient following rules strictly.
DPs:
{ 1: activate^#(n__s(X)) -> c_4(activate^#(X))
, 2: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X)) }
Trs:
{ activate(n__s(X)) -> s(activate(X))
, s(X) -> n__s(X) }
Sub-proof:
----------
The following argument positions are usable:
Uargs(c_1) = {1, 2, 3, 4}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
Uargs(c_4) = {1}
TcT has computed the following constructor-based matrix
interpretation satisfying not(EDA).
[tt] = [0]
[splitAt](x1, x2) = [0]
[activate](x1) = [3] x1 + [0]
[pair](x1, x2) = [1] x1 + [0]
[cons](x1, x2) = [0]
[natsFrom](x1) = [1] x1 + [0]
[n__natsFrom](x1) = [1] x1 + [0]
[n__s](x1) = [1] x1 + [4]
[0] = [0]
[nil] = [0]
[s](x1) = [1] x1 + [7]
[U11^#](x1, x2, x3, x4) = [7] x2 + [7] x3 + [7] x4 + [5]
[U12^#](x1, x2) = [2] x2 + [0]
[activate^#](x1) = [1] x1 + [0]
[c_1](x1, x2, x3, x4) = [1] x1 + [4] x2 + [4] x3 + [1] x4 + [0]
[c_2](x1) = [2] x1 + [0]
[c_3](x1) = [1] x1 + [0]
[c_4](x1) = [1] x1 + [3]
The order satisfies the following ordering constraints:
[splitAt(0(), XS)] = [0]
>= [0]
= [pair(nil(), XS)]
[activate(X)] = [3] X + [0]
>= [1] X + [0]
= [X]
[activate(n__natsFrom(X))] = [3] X + [0]
>= [3] X + [0]
= [natsFrom(activate(X))]
[activate(n__s(X))] = [3] X + [12]
> [3] X + [7]
= [s(activate(X))]
[natsFrom(N)] = [1] N + [0]
>= [0]
= [cons(N, n__natsFrom(n__s(N)))]
[natsFrom(X)] = [1] X + [0]
>= [1] X + [0]
= [n__natsFrom(X)]
[s(X)] = [1] X + [7]
> [1] X + [4]
= [n__s(X)]
[U11^#(tt(), N, X, XS)] = [7] N + [7] X + [7] XS + [5]
> [4] N + [7] X + [4] XS + [0]
= [c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))]
[U12^#(pair(YS, ZS), X)] = [2] X + [0]
>= [2] X + [0]
= [c_2(activate^#(X))]
[activate^#(n__natsFrom(X))] = [1] X + [0]
>= [1] X + [0]
= [c_3(activate^#(X))]
[activate^#(n__s(X))] = [1] X + [4]
> [1] X + [3]
= [c_4(activate^#(X))]
We return to the main proof. Consider the set of all dependency
pairs
:
{ 1: activate^#(n__s(X)) -> c_4(activate^#(X))
, 2: U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, 3: U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, 4: activate^#(n__natsFrom(X)) -> c_3(activate^#(X)) }
Processor 'matrix interpretation of dimension 1' induces the
complexity certificate YES(?,O(n^1)) on application of dependency
pairs {1,2}. These cover all (indirect) predecessors of dependency
pairs {1,2,3}, their number of application is equally bounded. The
dependency pairs are shifted into the weak component.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
No rule is usable, rules are removed from the input problem.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
S) We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Strict DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.
{ activate^#(n__natsFrom(X)) -> c_3(activate^#(X))
, activate^#(n__s(X)) -> c_4(activate^#(X)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Strict DPs: { U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X)) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:
{ U11^#(tt(), N, X, XS) ->
c_1(U12^#(splitAt(activate(N), activate(XS)), activate(X)),
activate^#(N),
activate^#(XS),
activate^#(X))
, U12^#(pair(YS, ZS), X) -> c_2(activate^#(X)) }
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Strict DPs: { U12^#(pair(YS, ZS), X) -> c_1() }
Weak DPs:
{ U11^#(tt(), N, X, XS) ->
c_2(U12^#(splitAt(activate(N), activate(XS)), activate(X))) }
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
The dependency graph contains no loops, we remove all dependency
pairs.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Weak Trs:
{ splitAt(0(), XS) -> pair(nil(), XS)
, activate(X) -> X
, activate(n__natsFrom(X)) -> natsFrom(activate(X))
, activate(n__s(X)) -> s(activate(X))
, natsFrom(N) -> cons(N, n__natsFrom(n__s(N)))
, natsFrom(X) -> n__natsFrom(X)
, s(X) -> n__s(X) }
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
No rule is usable, rules are removed from the input problem.
We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(1)).
Rules: Empty
Obligation:
innermost runtime complexity
Answer:
YES(O(1),O(1))
Empty rules are trivially bounded
Hurray, we answered YES(O(1),O(n^1))