/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES Problem 1: (VAR L X X1 X2) (RULES a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ) Problem 1: Dependency Pairs Processor: -> Pairs: A__ADX(cons(X,L)) -> A__INCR(cons(mark(X),adx(L))) A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__NATS -> A__ZEROS A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) MARK(zeros) -> A__ZEROS -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: SCC Processor: -> Pairs: A__ADX(cons(X,L)) -> A__INCR(cons(mark(X),adx(L))) A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__NATS -> A__ZEROS A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) MARK(zeros) -> A__ZEROS -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__ADX(cons(X,L)) -> A__INCR(cons(mark(X),adx(L))) A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__ADX(cons(X,L)) -> A__INCR(cons(mark(X),adx(L))) A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = 2.X + 1 [a__head](X) = X + 2 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = X + 1 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = 2.X + 1 [cons](X1,X2) = 2.X1 + X2 [head](X) = X + 2 [incr](X) = X [nats] = 2 [nil] = 1 [s](X) = X [tail](X) = X + 1 [zeros] = 0 [A__ADX](X) = 2.X + 2 [A__HEAD](X) = 2.X + 1 [A__INCR](X) = X [A__NATS] = 2 [A__TAIL](X) = 2.X + 2 [MARK](X) = 2.X Problem 1: SCC Processor: -> Pairs: A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__ADX(cons(X,L)) -> MARK(X) A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = 2.X + 2 [a__head](X) = 2.X + 2 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = 2.X + 1 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = 2.X + 2 [cons](X1,X2) = 2.X1 + X2 [head](X) = 2.X + 2 [incr](X) = X [nats] = 2 [nil] = 2 [s](X) = X [tail](X) = 2.X + 1 [zeros] = 0 [A__ADX](X) = X + 2 [A__HEAD](X) = 2.X + 2 [A__INCR](X) = X + 1 [A__NATS] = 2 [A__TAIL](X) = 2.X + 2 [MARK](X) = 2.X + 1 Problem 1: SCC Processor: -> Pairs: A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__NATS -> A__ADX(a__zeros) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> A__ADX(mark(X)) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(nats) -> A__NATS MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__HEAD(cons(X,L)) -> MARK(X) A__INCR(cons(X,L)) -> MARK(X) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = 2.X [a__head](X) = 2.X + 1 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = 2.X + 2 [a__zeros] = 1 [mark](X) = X [0] = 0 [adx](X) = 2.X [cons](X1,X2) = 2.X1 + X2 [head](X) = 2.X + 1 [incr](X) = X [nats] = 2 [nil] = 2 [s](X) = X [tail](X) = 2.X + 2 [zeros] = 1 [A__HEAD](X) = 2.X + 2 [A__INCR](X) = 2.X + 1 [A__TAIL](X) = 2.X + 2 [MARK](X) = 2.X + 1 Problem 1: SCC Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> A__HEAD(mark(X)) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__INCR(cons(X,L)) -> MARK(X) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) A__TAIL(cons(X,L)) -> MARK(L) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = X [a__head](X) = 2.X + 2 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = X + 2 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = X [cons](X1,X2) = 2.X1 + 2.X2 [head](X) = 2.X + 2 [incr](X) = X [nats] = 2 [nil] = 2 [s](X) = X [tail](X) = X + 2 [zeros] = 0 [A__INCR](X) = X + 1 [A__TAIL](X) = 2.X + 2 [MARK](X) = 2.X + 1 Problem 1: SCC Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> A__TAIL(mark(X)) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(adx(X)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = X + 2 [a__head](X) = X [a__incr](X) = X [a__nats] = 2 [a__tail](X) = 2.X + 2 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = X + 2 [cons](X1,X2) = 2.X1 + X2 [head](X) = X [incr](X) = X [nats] = 2 [nil] = 2 [s](X) = X [tail](X) = 2.X + 2 [zeros] = 0 [A__INCR](X) = 2.X + 1 [MARK](X) = 2.X + 1 Problem 1: SCC Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(head(X)) -> MARK(X) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = 2.X + 2 [a__head](X) = 2.X + 2 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = 2.X + 1 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = 2.X + 2 [cons](X1,X2) = 2.X1 + X2 [head](X) = 2.X + 2 [incr](X) = X [nats] = 2 [nil] = 2 [s](X) = X [tail](X) = 2.X + 1 [zeros] = 0 [A__INCR](X) = X + 2 [MARK](X) = X + 2 Problem 1: SCC Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) MARK(tail(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: Natural Numbers ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = 2.X [a__head](X) = 2.X + 2 [a__incr](X) = X [a__nats] = 1 [a__tail](X) = 2.X + 1 [a__zeros] = 0 [mark](X) = X [0] = 0 [adx](X) = 2.X [cons](X1,X2) = 2.X1 + 2.X2 [head](X) = 2.X + 2 [incr](X) = X [nats] = 1 [nil] = 2 [s](X) = X [tail](X) = 2.X + 1 [zeros] = 0 [A__INCR](X) = X + 2 [MARK](X) = X + 2 Problem 1: SCC Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Reduction Pair Processor: -> Pairs: A__INCR(cons(X,L)) -> MARK(X) MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros -> Usable rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Interpretation type: Linear ->Coefficients: All rationals ->Dimension: 1 ->Bound: 2 ->Interpretation: [a__adx](X) = X + 1/2 [a__head](X) = X + 2 [a__incr](X) = X [a__nats] = 2 [a__tail](X) = 2.X + 1/2 [a__zeros] = 1 [mark](X) = X [0] = 0 [adx](X) = X + 1/2 [cons](X1,X2) = 2.X1 + 1/2.X2 + 1/2 [head](X) = X + 2 [incr](X) = X [nats] = 2 [nil] = 0 [s](X) = X [tail](X) = 2.X + 1/2 [zeros] = 1 [A__INCR](X) = 1/2.X [MARK](X) = X Problem 1: SCC Processor: -> Pairs: MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> A__INCR(mark(X)) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: ->->Cycle: ->->-> Pairs: MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) ->->-> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros Problem 1: Subterm Processor: -> Pairs: MARK(cons(X1,X2)) -> MARK(X1) MARK(incr(X)) -> MARK(X) MARK(s(X)) -> MARK(X) -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Projection: pi(MARK) = 1 Problem 1: SCC Processor: -> Pairs: Empty -> Rules: a__adx(cons(X,L)) -> a__incr(cons(mark(X),adx(L))) a__adx(nil) -> nil a__adx(X) -> adx(X) a__head(cons(X,L)) -> mark(X) a__head(X) -> head(X) a__incr(cons(X,L)) -> cons(s(mark(X)),incr(L)) a__incr(nil) -> nil a__incr(X) -> incr(X) a__nats -> a__adx(a__zeros) a__nats -> nats a__tail(cons(X,L)) -> mark(L) a__tail(X) -> tail(X) a__zeros -> cons(0,zeros) a__zeros -> zeros mark(0) -> 0 mark(adx(X)) -> a__adx(mark(X)) mark(cons(X1,X2)) -> cons(mark(X1),X2) mark(head(X)) -> a__head(mark(X)) mark(incr(X)) -> a__incr(mark(X)) mark(nats) -> a__nats mark(nil) -> nil mark(s(X)) -> s(mark(X)) mark(tail(X)) -> a__tail(mark(X)) mark(zeros) -> a__zeros ->Strongly Connected Components: There is no strongly connected component The problem is finite.