/export/starexec/sandbox2/solver/bin/starexec_run_default /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- YES Problem 1: (VAR v_NonEmpty:S N:S X:S X1:S X2:S XS:S) (RULES 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ) Problem 1: Dependency Pairs Processor: -> Pairs: 2ND(cons(X:S,XS:S)) -> ACTIVATE(XS:S) 2ND(cons(X:S,XS:S)) -> HEAD(activate(XS:S)) ACTIVATE(n__from(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__from(X:S)) -> FROM(activate(X:S)) ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__s(X:S)) -> S(activate(X:S)) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) SEL(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) SEL(s(N:S),cons(X:S,XS:S)) -> SEL(N:S,activate(XS:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) Problem 1: SCC Processor: -> Pairs: 2ND(cons(X:S,XS:S)) -> ACTIVATE(XS:S) 2ND(cons(X:S,XS:S)) -> HEAD(activate(XS:S)) ACTIVATE(n__from(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__from(X:S)) -> FROM(activate(X:S)) ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__s(X:S)) -> S(activate(X:S)) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) SEL(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) SEL(s(N:S),cons(X:S,XS:S)) -> SEL(N:S,activate(XS:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVATE(n__from(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->->Cycle: ->->-> Pairs: SEL(s(N:S),cons(X:S,XS:S)) -> SEL(N:S,activate(XS:S)) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) The problem is decomposed in 2 subproblems. Problem 1.1: Reduction Pair Processor: -> Pairs: ACTIVATE(n__from(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) -> Usable rules: activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) s(X:S) -> n__s(X:S) take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [activate](X) = X [from](X) = X + 2 [s](X) = X [take](X1,X2) = 2.X1 + 2.X2 + 1 [0] = 2 [cons](X1,X2) = X2 [n__from](X) = X + 2 [n__s](X) = X [n__take](X1,X2) = 2.X1 + 2.X2 + 1 [nil] = 2 [ACTIVATE](X) = 2.X + 2 [TAKE](X1,X2) = X1 + 2.X2 + 2 Problem 1.1: SCC Processor: -> Pairs: ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) Problem 1.1: Reduction Pair Processor: -> Pairs: ACTIVATE(n__s(X:S)) -> ACTIVATE(X:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) -> Usable rules: activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) s(X:S) -> n__s(X:S) take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [activate](X) = X [from](X) = 0 [s](X) = 2.X + 2 [take](X1,X2) = 2.X1 + 2.X2 + 1 [0] = 1 [cons](X1,X2) = 2.X2 [n__from](X) = 0 [n__s](X) = 2.X + 2 [n__take](X1,X2) = 2.X1 + 2.X2 + 1 [nil] = 2 [ACTIVATE](X) = 2.X + 2 [TAKE](X1,X2) = 2.X2 + 2 Problem 1.1: SCC Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) Problem 1.1: Reduction Pair Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X1:S) ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) -> Usable rules: activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) s(X:S) -> n__s(X:S) take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [activate](X) = X [from](X) = 0 [s](X) = 2.X + 1 [take](X1,X2) = 2.X1 + X2 + 1 [0] = 0 [cons](X1,X2) = 2.X2 [n__from](X) = 0 [n__s](X) = 2.X + 1 [n__take](X1,X2) = 2.X1 + X2 + 1 [nil] = 1 [ACTIVATE](X) = 2.X + 2 [TAKE](X1,X2) = 2.X1 + 2.X2 + 1 Problem 1.1: SCC Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) Problem 1.1: Reduction Pair Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> ACTIVATE(X2:S) ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) -> Usable rules: activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) s(X:S) -> n__s(X:S) take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [activate](X) = X [from](X) = 0 [s](X) = 2.X + 1 [take](X1,X2) = 2.X1 + 2.X2 + 1 [0] = 2 [cons](X1,X2) = 2.X2 [n__from](X) = 0 [n__s](X) = 2.X + 1 [n__take](X1,X2) = 2.X1 + 2.X2 + 1 [nil] = 2 [ACTIVATE](X) = X + 1 [TAKE](X1,X2) = 2.X1 + 2.X2 + 2 Problem 1.1: SCC Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) ->->-> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) Problem 1.1: Reduction Pair Processor: -> Pairs: ACTIVATE(n__take(X1:S,X2:S)) -> TAKE(activate(X1:S),activate(X2:S)) TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) -> Usable rules: activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) s(X:S) -> n__s(X:S) take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [activate](X) = X [from](X) = 0 [s](X) = 2.X + 2 [take](X1,X2) = 2.X1 + 2.X2 + 2 [0] = 2 [cons](X1,X2) = 2.X2 [n__from](X) = 0 [n__s](X) = 2.X + 2 [n__take](X1,X2) = 2.X1 + 2.X2 + 2 [nil] = 1 [ACTIVATE](X) = 2.X + 1 [TAKE](X1,X2) = X1 + X2 Problem 1.1: SCC Processor: -> Pairs: TAKE(s(N:S),cons(X:S,XS:S)) -> ACTIVATE(XS:S) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: There is no strongly connected component The problem is finite. Problem 1.2: Subterm Processor: -> Pairs: SEL(s(N:S),cons(X:S,XS:S)) -> SEL(N:S,activate(XS:S)) -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Projection: pi(SEL) = 1 Problem 1.2: SCC Processor: -> Pairs: Empty -> Rules: 2nd(cons(X:S,XS:S)) -> head(activate(XS:S)) activate(n__from(X:S)) -> from(activate(X:S)) activate(n__s(X:S)) -> s(activate(X:S)) activate(n__take(X1:S,X2:S)) -> take(activate(X1:S),activate(X2:S)) activate(X:S) -> X:S from(X:S) -> cons(X:S,n__from(n__s(X:S))) from(X:S) -> n__from(X:S) head(cons(X:S,XS:S)) -> X:S s(X:S) -> n__s(X:S) sel(s(N:S),cons(X:S,XS:S)) -> sel(N:S,activate(XS:S)) sel(0,cons(X:S,XS:S)) -> X:S take(s(N:S),cons(X:S,XS:S)) -> cons(X:S,n__take(N:S,activate(XS:S))) take(0,XS:S) -> nil take(X1:S,X2:S) -> n__take(X1:S,X2:S) ->Strongly Connected Components: There is no strongly connected component The problem is finite.