/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES Problem: active(incr(nil())) -> mark(nil()) active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(nil())) -> mark(nil()) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(nats()) -> mark(adx(zeros())) active(zeros()) -> mark(cons(0(),zeros())) active(head(cons(X,L))) -> mark(X) active(tail(cons(X,L))) -> mark(L) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(X1,mark(X2)) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) cons(X1,active(X2)) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Proof: Matrix Interpretation Processor: dim=1 interpretation: [tail](x0) = x0, [head](x0) = 2x0, [0] = 0, [zeros] = 0, [nats] = 6, [adx](x0) = 3x0, [s](x0) = x0, [cons](x0, x1) = 2x0 + x1, [mark](x0) = x0, [active](x0) = x0, [incr](x0) = x0, [nil] = 0 orientation: active(incr(nil())) = 0 >= 0 = mark(nil()) active(incr(cons(X,L))) = L + 2X >= L + 2X = mark(cons(s(X),incr(L))) active(adx(nil())) = 0 >= 0 = mark(nil()) active(adx(cons(X,L))) = 3L + 6X >= 3L + 2X = mark(incr(cons(X,adx(L)))) active(nats()) = 6 >= 0 = mark(adx(zeros())) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(head(cons(X,L))) = 2L + 4X >= X = mark(X) active(tail(cons(X,L))) = L + 2X >= L = mark(L) mark(incr(X)) = X >= X = active(incr(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(cons(X1,X2)) = 2X1 + X2 >= 2X1 + X2 = active(cons(mark(X1),X2)) mark(s(X)) = X >= X = active(s(mark(X))) mark(adx(X)) = 3X >= 3X = active(adx(mark(X))) mark(nats()) = 6 >= 6 = active(nats()) mark(zeros()) = 0 >= 0 = active(zeros()) mark(0()) = 0 >= 0 = active(0()) mark(head(X)) = 2X >= 2X = active(head(mark(X))) mark(tail(X)) = X >= X = active(tail(mark(X))) incr(mark(X)) = X >= X = incr(X) incr(active(X)) = X >= X = incr(X) cons(mark(X1),X2) = 2X1 + X2 >= 2X1 + X2 = cons(X1,X2) cons(X1,mark(X2)) = 2X1 + X2 >= 2X1 + X2 = cons(X1,X2) cons(active(X1),X2) = 2X1 + X2 >= 2X1 + X2 = cons(X1,X2) cons(X1,active(X2)) = 2X1 + X2 >= 2X1 + X2 = cons(X1,X2) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) adx(mark(X)) = 3X >= 3X = adx(X) adx(active(X)) = 3X >= 3X = adx(X) head(mark(X)) = 2X >= 2X = head(X) head(active(X)) = 2X >= 2X = head(X) tail(mark(X)) = X >= X = tail(X) tail(active(X)) = X >= X = tail(X) problem: active(incr(nil())) -> mark(nil()) active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(nil())) -> mark(nil()) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) active(head(cons(X,L))) -> mark(X) active(tail(cons(X,L))) -> mark(L) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(X1,mark(X2)) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) cons(X1,active(X2)) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Matrix Interpretation Processor: dim=1 interpretation: [tail](x0) = x0, [head](x0) = 4x0 + 4, [0] = 0, [zeros] = 0, [nats] = 0, [adx](x0) = 2x0, [s](x0) = x0, [cons](x0, x1) = x0 + 2x1, [mark](x0) = x0, [active](x0) = x0, [incr](x0) = x0, [nil] = 2 orientation: active(incr(nil())) = 2 >= 2 = mark(nil()) active(incr(cons(X,L))) = 2L + X >= 2L + X = mark(cons(s(X),incr(L))) active(adx(nil())) = 4 >= 2 = mark(nil()) active(adx(cons(X,L))) = 4L + 2X >= 4L + X = mark(incr(cons(X,adx(L)))) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(head(cons(X,L))) = 8L + 4X + 4 >= X = mark(X) active(tail(cons(X,L))) = 2L + X >= L = mark(L) mark(incr(X)) = X >= X = active(incr(mark(X))) mark(nil()) = 2 >= 2 = active(nil()) mark(cons(X1,X2)) = X1 + 2X2 >= X1 + 2X2 = active(cons(mark(X1),X2)) mark(s(X)) = X >= X = active(s(mark(X))) mark(adx(X)) = 2X >= 2X = active(adx(mark(X))) mark(nats()) = 0 >= 0 = active(nats()) mark(zeros()) = 0 >= 0 = active(zeros()) mark(0()) = 0 >= 0 = active(0()) mark(head(X)) = 4X + 4 >= 4X + 4 = active(head(mark(X))) mark(tail(X)) = X >= X = active(tail(mark(X))) incr(mark(X)) = X >= X = incr(X) incr(active(X)) = X >= X = incr(X) cons(mark(X1),X2) = X1 + 2X2 >= X1 + 2X2 = cons(X1,X2) cons(X1,mark(X2)) = X1 + 2X2 >= X1 + 2X2 = cons(X1,X2) cons(active(X1),X2) = X1 + 2X2 >= X1 + 2X2 = cons(X1,X2) cons(X1,active(X2)) = X1 + 2X2 >= X1 + 2X2 = cons(X1,X2) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) adx(mark(X)) = 2X >= 2X = adx(X) adx(active(X)) = 2X >= 2X = adx(X) head(mark(X)) = 4X + 4 >= 4X + 4 = head(X) head(active(X)) = 4X + 4 >= 4X + 4 = head(X) tail(mark(X)) = X >= X = tail(X) tail(active(X)) = X >= X = tail(X) problem: active(incr(nil())) -> mark(nil()) active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) active(tail(cons(X,L))) -> mark(L) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(X1,mark(X2)) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) cons(X1,active(X2)) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Matrix Interpretation Processor: dim=3 interpretation: [1 0 0] [1] [tail](x0) = [0 0 0]x0 + [0] [0 0 0] [0], [1 0 0] [head](x0) = [0 0 0]x0 [0 0 0] , [0] [0] = [0] [0], [0] [zeros] = [0] [0], [0] [nats] = [0] [0], [1 0 0] [1] [adx](x0) = [0 0 0]x0 + [0] [0 0 0] [0], [1 0 0] [0] [s](x0) = [0 0 0]x0 + [0] [0 0 0] [1], [1 0 0] [1 0 0] [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 [0 0 0] [0 0 0] , [1 0 0] [mark](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [active](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [0] [incr](x0) = [0 0 0]x0 + [1] [0 0 0] [0], [1] [nil] = [0] [0] orientation: [1] [1] active(incr(nil())) = [0] >= [0] = mark(nil()) [0] [0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] active(incr(cons(X,L))) = [0 0 0]L + [0 0 0]X >= [0 0 0]L + [0 0 0]X = mark(cons(s(X),incr(L))) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1] [1 0 0] [1 0 0] [1] active(adx(cons(X,L))) = [0 0 0]L + [0 0 0]X + [0] >= [0 0 0]L + [0 0 0]X + [0] = mark(incr(cons(X,adx(L)))) [0 0 0] [0 0 0] [0] [0 0 0] [0 0 0] [0] [0] [0] active(zeros()) = [0] >= [0] = mark(cons(0(),zeros())) [0] [0] [1 0 0] [1 0 0] [1] [1 0 0] active(tail(cons(X,L))) = [0 0 0]L + [0 0 0]X + [0] >= [0 0 0]L = mark(L) [0 0 0] [0 0 0] [0] [0 0 0] [1 0 0] [1 0 0] mark(incr(X)) = [0 0 0]X >= [0 0 0]X = active(incr(mark(X))) [0 0 0] [0 0 0] [1] [1] mark(nil()) = [0] >= [0] = active(nil()) [0] [0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] mark(cons(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = active(cons(mark(X1),X2)) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] mark(s(X)) = [0 0 0]X >= [0 0 0]X = active(s(mark(X))) [0 0 0] [0 0 0] [1 0 0] [1] [1 0 0] [1] mark(adx(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(adx(mark(X))) [0 0 0] [0] [0 0 0] [0] [0] [0] mark(nats()) = [0] >= [0] = active(nats()) [0] [0] [0] [0] mark(zeros()) = [0] >= [0] = active(zeros()) [0] [0] [0] [0] mark(0()) = [0] >= [0] = active(0()) [0] [0] [1 0 0] [1 0 0] mark(head(X)) = [0 0 0]X >= [0 0 0]X = active(head(mark(X))) [0 0 0] [0 0 0] [1 0 0] [1] [1 0 0] [1] mark(tail(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(tail(mark(X))) [0 0 0] [0] [0 0 0] [0] [1 0 0] [0] [1 0 0] [0] incr(mark(X)) = [0 0 0]X + [1] >= [0 0 0]X + [1] = incr(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [0] [1 0 0] [0] incr(active(X)) = [0 0 0]X + [1] >= [0 0 0]X + [1] = incr(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(X1,mark(X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(X1,active(X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [0] [1 0 0] [0] s(mark(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = s(X) [0 0 0] [1] [0 0 0] [1] [1 0 0] [0] [1 0 0] [0] s(active(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = s(X) [0 0 0] [1] [0 0 0] [1] [1 0 0] [1] [1 0 0] [1] adx(mark(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = adx(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [1] [1 0 0] [1] adx(active(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = adx(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [1 0 0] head(mark(X)) = [0 0 0]X >= [0 0 0]X = head(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] head(active(X)) = [0 0 0]X >= [0 0 0]X = head(X) [0 0 0] [0 0 0] [1 0 0] [1] [1 0 0] [1] tail(mark(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = tail(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [1] [1 0 0] [1] tail(active(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = tail(X) [0 0 0] [0] [0 0 0] [0] problem: active(incr(nil())) -> mark(nil()) active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(X1,mark(X2)) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) cons(X1,active(X2)) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Matrix Interpretation Processor: dim=3 interpretation: [1 0 0] [tail](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [0] [head](x0) = [0 0 0]x0 + [1] [0 0 0] [0], [0] [0] = [0] [0], [0] [zeros] = [0] [0], [1] [nats] = [0] [0], [1 0 0] [adx](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [s](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [1 0 1] [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 [0 0 0] [0 0 0] , [1 0 0] [0] [mark](x0) = [0 0 0]x0 + [0] [0 0 1] [1], [1 0 1] [0] [active](x0) = [0 0 0]x0 + [0] [0 0 0] [1], [1 0 0] [incr](x0) = [1 0 0]x0 [0 0 0] , [0] [nil] = [0] [0] orientation: [0] [0] active(incr(nil())) = [0] >= [0] = mark(nil()) [1] [1] [1 0 1] [1 0 0] [0] [1 0 0] [1 0 0] [0] active(incr(cons(X,L))) = [0 0 0]L + [0 0 0]X + [0] >= [0 0 0]L + [0 0 0]X + [0] = mark(cons(s(X),incr(L))) [0 0 0] [0 0 0] [1] [0 0 0] [0 0 0] [1] [1 0 1] [1 0 0] [0] [1 0 0] [1 0 0] [0] active(adx(cons(X,L))) = [0 0 0]L + [0 0 0]X + [0] >= [0 0 0]L + [0 0 0]X + [0] = mark(incr(cons(X,adx(L)))) [0 0 0] [0 0 0] [1] [0 0 0] [0 0 0] [1] [0] [0] active(zeros()) = [0] >= [0] = mark(cons(0(),zeros())) [1] [1] [1 0 0] [0] [1 0 0] [0] mark(incr(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(incr(mark(X))) [0 0 0] [1] [0 0 0] [1] [0] [0] mark(nil()) = [0] >= [0] = active(nil()) [1] [1] [1 0 0] [1 0 1] [0] [1 0 0] [1 0 1] [0] mark(cons(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 + [0] = active(cons(mark(X1),X2)) [0 0 0] [0 0 0] [1] [0 0 0] [0 0 0] [1] [1 0 0] [0] [1 0 0] [0] mark(s(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(s(mark(X))) [0 0 0] [1] [0 0 0] [1] [1 0 0] [0] [1 0 0] [0] mark(adx(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(adx(mark(X))) [0 0 0] [1] [0 0 0] [1] [1] [1] mark(nats()) = [0] >= [0] = active(nats()) [1] [1] [0] [0] mark(zeros()) = [0] >= [0] = active(zeros()) [1] [1] [0] [0] mark(0()) = [0] >= [0] = active(0()) [1] [1] [1 0 0] [0] [1 0 0] [0] mark(head(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(head(mark(X))) [0 0 0] [1] [0 0 0] [1] [1 0 0] [0] [1 0 0] [0] mark(tail(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(tail(mark(X))) [0 0 0] [1] [0 0 0] [1] [1 0 0] [1 0 0] incr(mark(X)) = [1 0 0]X >= [1 0 0]X = incr(X) [0 0 0] [0 0 0] [1 0 1] [1 0 0] incr(active(X)) = [1 0 1]X >= [1 0 0]X = incr(X) [0 0 0] [0 0 0] [1 0 0] [1 0 1] [1 0 0] [1 0 1] cons(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 1] [1] [1 0 0] [1 0 1] cons(X1,mark(X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0] [0 0 0] [0 0 0] [1 0 1] [1 0 1] [1 0 0] [1 0 1] cons(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1 0 0] [1 0 1] [1] [1 0 0] [1 0 1] cons(X1,active(X2)) = [0 0 0]X1 + [0 0 0]X2 + [0] >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 0 0] [0] [0 0 0] [0 0 0] [1 0 0] [1 0 0] s(mark(X)) = [0 0 0]X >= [0 0 0]X = s(X) [0 0 0] [0 0 0] [1 0 1] [1 0 0] s(active(X)) = [0 0 0]X >= [0 0 0]X = s(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] adx(mark(X)) = [0 0 0]X >= [0 0 0]X = adx(X) [0 0 0] [0 0 0] [1 0 1] [1 0 0] adx(active(X)) = [0 0 0]X >= [0 0 0]X = adx(X) [0 0 0] [0 0 0] [1 0 0] [0] [1 0 0] [0] head(mark(X)) = [0 0 0]X + [1] >= [0 0 0]X + [1] = head(X) [0 0 0] [0] [0 0 0] [0] [1 0 1] [0] [1 0 0] [0] head(active(X)) = [0 0 0]X + [1] >= [0 0 0]X + [1] = head(X) [0 0 0] [0] [0 0 0] [0] [1 0 0] [1 0 0] tail(mark(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [0 0 0] [0 0 0] [1 0 1] [1 0 0] tail(active(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [0 0 0] [0 0 0] problem: active(incr(nil())) -> mark(nil()) active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Matrix Interpretation Processor: dim=3 interpretation: [1 0 0] [tail](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [head](x0) = [0 0 0]x0 [0 0 0] , [0] [0] = [0] [0], [1] [zeros] = [0] [1], [1] [nats] = [0] [0], [1 0 0] [adx](x0) = [0 0 0]x0 [0 0 0] , [1 0 0] [0] [s](x0) = [0 0 0]x0 + [0] [0 0 0] [1], [1 0 0] [1 0 0] [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 [0 0 0] [0 1 1] , [1 0 0] [mark](x0) = [0 0 0]x0 [0 1 1] , [1 0 0] [active](x0) = [0 0 0]x0 [0 1 1] , [1 1 1] [incr](x0) = [0 1 1]x0 [0 0 0] , [0] [nil] = [1] [0] orientation: [1] [0] active(incr(nil())) = [0] >= [0] = mark(nil()) [1] [1] [1 1 1] [1 0 0] [1 1 1] [1 0 0] active(incr(cons(X,L))) = [0 0 0]L + [0 0 0]X >= [0 0 0]L + [0 0 0]X = mark(cons(s(X),incr(L))) [0 1 1] [0 0 0] [0 1 1] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] active(adx(cons(X,L))) = [0 0 0]L + [0 0 0]X >= [0 0 0]L + [0 0 0]X = mark(incr(cons(X,adx(L)))) [0 0 0] [0 0 0] [0 0 0] [0 0 0] [1] [1] active(zeros()) = [0] >= [0] = mark(cons(0(),zeros())) [1] [1] [1 1 1] [1 1 1] mark(incr(X)) = [0 0 0]X >= [0 0 0]X = active(incr(mark(X))) [0 1 1] [0 1 1] [0] [0] mark(nil()) = [0] >= [0] = active(nil()) [1] [1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] mark(cons(X1,X2)) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = active(cons(mark(X1),X2)) [0 0 0] [0 1 1] [0 0 0] [0 1 1] [1 0 0] [0] [1 0 0] [0] mark(s(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = active(s(mark(X))) [0 0 0] [1] [0 0 0] [1] [1 0 0] [1 0 0] mark(adx(X)) = [0 0 0]X >= [0 0 0]X = active(adx(mark(X))) [0 0 0] [0 0 0] [1] [1] mark(nats()) = [0] >= [0] = active(nats()) [0] [0] [1] [1] mark(zeros()) = [0] >= [0] = active(zeros()) [1] [1] [0] [0] mark(0()) = [0] >= [0] = active(0()) [0] [0] [1 0 0] [1 0 0] mark(head(X)) = [0 0 0]X >= [0 0 0]X = active(head(mark(X))) [0 0 0] [0 0 0] [1 0 0] [1 0 0] mark(tail(X)) = [0 0 0]X >= [0 0 0]X = active(tail(mark(X))) [0 0 0] [0 0 0] [1 1 1] [1 1 1] incr(mark(X)) = [0 1 1]X >= [0 1 1]X = incr(X) [0 0 0] [0 0 0] [1 1 1] [1 1 1] incr(active(X)) = [0 1 1]X >= [0 1 1]X = incr(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(mark(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 1 1] [0 0 0] [0 1 1] [1 0 0] [1 0 0] [1 0 0] [1 0 0] cons(active(X1),X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2) [0 0 0] [0 1 1] [0 0 0] [0 1 1] [1 0 0] [0] [1 0 0] [0] s(mark(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = s(X) [0 0 0] [1] [0 0 0] [1] [1 0 0] [0] [1 0 0] [0] s(active(X)) = [0 0 0]X + [0] >= [0 0 0]X + [0] = s(X) [0 0 0] [1] [0 0 0] [1] [1 0 0] [1 0 0] adx(mark(X)) = [0 0 0]X >= [0 0 0]X = adx(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] adx(active(X)) = [0 0 0]X >= [0 0 0]X = adx(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] head(mark(X)) = [0 0 0]X >= [0 0 0]X = head(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] head(active(X)) = [0 0 0]X >= [0 0 0]X = head(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] tail(mark(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [0 0 0] [0 0 0] [1 0 0] [1 0 0] tail(active(X)) = [0 0 0]X >= [0 0 0]X = tail(X) [0 0 0] [0 0 0] problem: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) DP Processor: DPs: active#(incr(cons(X,L))) -> incr#(L) active#(incr(cons(X,L))) -> s#(X) active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) active#(adx(cons(X,L))) -> adx#(L) active#(adx(cons(X,L))) -> cons#(X,adx(L)) active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) active#(zeros()) -> cons#(0(),zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> incr#(mark(X)) mark#(incr(X)) -> active#(incr(mark(X))) mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> adx#(mark(X)) mark#(adx(X)) -> active#(adx(mark(X))) mark#(nats()) -> active#(nats()) mark#(zeros()) -> active#(zeros()) mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) mark#(head(X)) -> head#(mark(X)) mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> tail#(mark(X)) mark#(tail(X)) -> active#(tail(mark(X))) incr#(mark(X)) -> incr#(X) incr#(active(X)) -> incr#(X) cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) adx#(mark(X)) -> adx#(X) adx#(active(X)) -> adx#(X) head#(mark(X)) -> head#(X) head#(active(X)) -> head#(X) tail#(mark(X)) -> tail#(X) tail#(active(X)) -> tail#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) TDG Processor: DPs: active#(incr(cons(X,L))) -> incr#(L) active#(incr(cons(X,L))) -> s#(X) active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) active#(adx(cons(X,L))) -> adx#(L) active#(adx(cons(X,L))) -> cons#(X,adx(L)) active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) active#(zeros()) -> cons#(0(),zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> incr#(mark(X)) mark#(incr(X)) -> active#(incr(mark(X))) mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> adx#(mark(X)) mark#(adx(X)) -> active#(adx(mark(X))) mark#(nats()) -> active#(nats()) mark#(zeros()) -> active#(zeros()) mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) mark#(head(X)) -> head#(mark(X)) mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> tail#(mark(X)) mark#(tail(X)) -> active#(tail(mark(X))) incr#(mark(X)) -> incr#(X) incr#(active(X)) -> incr#(X) cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) adx#(mark(X)) -> adx#(X) adx#(active(X)) -> adx#(X) head#(mark(X)) -> head#(X) head#(active(X)) -> head#(X) tail#(mark(X)) -> tail#(X) tail#(active(X)) -> tail#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) graph: tail#(mark(X)) -> tail#(X) -> tail#(active(X)) -> tail#(X) tail#(mark(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X) tail#(active(X)) -> tail#(X) -> tail#(active(X)) -> tail#(X) tail#(active(X)) -> tail#(X) -> tail#(mark(X)) -> tail#(X) head#(mark(X)) -> head#(X) -> head#(active(X)) -> head#(X) head#(mark(X)) -> head#(X) -> head#(mark(X)) -> head#(X) head#(active(X)) -> head#(X) -> head#(active(X)) -> head#(X) head#(active(X)) -> head#(X) -> head#(mark(X)) -> head#(X) adx#(mark(X)) -> adx#(X) -> adx#(active(X)) -> adx#(X) adx#(mark(X)) -> adx#(X) -> adx#(mark(X)) -> adx#(X) adx#(active(X)) -> adx#(X) -> adx#(active(X)) -> adx#(X) adx#(active(X)) -> adx#(X) -> adx#(mark(X)) -> adx#(X) mark#(tail(X)) -> tail#(mark(X)) -> tail#(active(X)) -> tail#(X) mark#(tail(X)) -> tail#(mark(X)) -> tail#(mark(X)) -> tail#(X) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(head(X)) -> head#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(tail(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(tail(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(tail(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(adx(X)) -> adx#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(zeros()) -> cons#(0(),zeros()) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(adx(cons(X,L))) -> adx#(L) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(incr(cons(X,L))) -> s#(X) mark#(tail(X)) -> active#(tail(mark(X))) -> active#(incr(cons(X,L))) -> incr#(L) mark#(head(X)) -> head#(mark(X)) -> head#(active(X)) -> head#(X) mark#(head(X)) -> head#(mark(X)) -> head#(mark(X)) -> head#(X) mark#(head(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(head(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(head(X)) -> head#(mark(X)) mark#(head(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(head(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(head(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(adx(X)) -> adx#(mark(X)) mark#(head(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(head(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(head(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(head(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(head(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(head(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(head(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(head(X)) -> active#(head(mark(X))) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(head(X)) -> active#(head(mark(X))) -> active#(zeros()) -> cons#(0(),zeros()) mark#(head(X)) -> active#(head(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(head(X)) -> active#(head(mark(X))) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(head(X)) -> active#(head(mark(X))) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(head(X)) -> active#(head(mark(X))) -> active#(adx(cons(X,L))) -> adx#(L) mark#(head(X)) -> active#(head(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(head(X)) -> active#(head(mark(X))) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(head(X)) -> active#(head(mark(X))) -> active#(incr(cons(X,L))) -> s#(X) mark#(head(X)) -> active#(head(mark(X))) -> active#(incr(cons(X,L))) -> incr#(L) mark#(0()) -> active#(0()) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(0()) -> active#(0()) -> active#(zeros()) -> cons#(0(),zeros()) mark#(0()) -> active#(0()) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(0()) -> active#(0()) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(0()) -> active#(0()) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(0()) -> active#(0()) -> active#(adx(cons(X,L))) -> adx#(L) mark#(0()) -> active#(0()) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(0()) -> active#(0()) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(0()) -> active#(0()) -> active#(incr(cons(X,L))) -> s#(X) mark#(0()) -> active#(0()) -> active#(incr(cons(X,L))) -> incr#(L) mark#(zeros()) -> active#(zeros()) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(zeros()) -> active#(zeros()) -> active#(zeros()) -> cons#(0(),zeros()) mark#(zeros()) -> active#(zeros()) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(zeros()) -> active#(zeros()) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(zeros()) -> active#(zeros()) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(zeros()) -> active#(zeros()) -> active#(adx(cons(X,L))) -> adx#(L) mark#(zeros()) -> active#(zeros()) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(zeros()) -> active#(zeros()) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(zeros()) -> active#(zeros()) -> active#(incr(cons(X,L))) -> s#(X) mark#(zeros()) -> active#(zeros()) -> active#(incr(cons(X,L))) -> incr#(L) mark#(nats()) -> active#(nats()) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(nats()) -> active#(nats()) -> active#(zeros()) -> cons#(0(),zeros()) mark#(nats()) -> active#(nats()) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(nats()) -> active#(nats()) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(nats()) -> active#(nats()) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(nats()) -> active#(nats()) -> active#(adx(cons(X,L))) -> adx#(L) mark#(nats()) -> active#(nats()) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(nats()) -> active#(nats()) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(nats()) -> active#(nats()) -> active#(incr(cons(X,L))) -> s#(X) mark#(nats()) -> active#(nats()) -> active#(incr(cons(X,L))) -> incr#(L) mark#(adx(X)) -> adx#(mark(X)) -> adx#(active(X)) -> adx#(X) mark#(adx(X)) -> adx#(mark(X)) -> adx#(mark(X)) -> adx#(X) mark#(adx(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(adx(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(head(X)) -> head#(mark(X)) mark#(adx(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(adx(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(adx(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(adx(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(adx(X)) -> adx#(mark(X)) mark#(adx(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(adx(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(adx(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(adx(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(adx(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(adx(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(zeros()) -> cons#(0(),zeros()) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(adx(cons(X,L))) -> adx#(L) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(incr(cons(X,L))) -> s#(X) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(incr(cons(X,L))) -> incr#(L) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(head(X)) -> head#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(s(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(s(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(s(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(adx(X)) -> adx#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X) mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X) mark#(s(X)) -> active#(s(mark(X))) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(s(X)) -> active#(s(mark(X))) -> active#(zeros()) -> cons#(0(),zeros()) mark#(s(X)) -> active#(s(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(s(X)) -> active#(s(mark(X))) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(s(X)) -> active#(s(mark(X))) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(s(X)) -> active#(s(mark(X))) -> active#(adx(cons(X,L))) -> adx#(L) mark#(s(X)) -> active#(s(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(s(X)) -> active#(s(mark(X))) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(s(X)) -> active#(s(mark(X))) -> active#(incr(cons(X,L))) -> s#(X) mark#(s(X)) -> active#(s(mark(X))) -> active#(incr(cons(X,L))) -> incr#(L) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> tail#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(head(X)) -> active#(head(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(head(X)) -> head#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(head(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nats()) -> active#(nats()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(adx(X)) -> adx#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(adx(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> incr#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(active(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(zeros()) -> cons#(0(),zeros()) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(adx(cons(X,L))) -> adx#(L) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(incr(cons(X,L))) -> s#(X) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(incr(cons(X,L))) -> incr#(L) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> tail#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(head(X)) -> head#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(incr(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(incr(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(incr(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(adx(X)) -> adx#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> incr#(mark(X)) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> incr#(mark(X)) -> incr#(active(X)) -> incr#(X) mark#(incr(X)) -> incr#(mark(X)) -> incr#(mark(X)) -> incr#(X) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(zeros()) -> cons#(0(),zeros()) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(adx(cons(X,L))) -> adx#(L) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,L))) -> s#(X) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,L))) -> incr#(L) mark#(nil()) -> active#(nil()) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(nil()) -> active#(nil()) -> active#(zeros()) -> cons#(0(),zeros()) mark#(nil()) -> active#(nil()) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(nil()) -> active#(nil()) -> active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) mark#(nil()) -> active#(nil()) -> active#(adx(cons(X,L))) -> cons#(X,adx(L)) mark#(nil()) -> active#(nil()) -> active#(adx(cons(X,L))) -> adx#(L) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,L))) -> s#(X) mark#(nil()) -> active#(nil()) -> active#(incr(cons(X,L))) -> incr#(L) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X) s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X) incr#(mark(X)) -> incr#(X) -> incr#(active(X)) -> incr#(X) incr#(mark(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X) incr#(active(X)) -> incr#(X) -> incr#(active(X)) -> incr#(X) incr#(active(X)) -> incr#(X) -> incr#(mark(X)) -> incr#(X) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(tail(X)) -> active#(tail(mark(X))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(tail(X)) -> tail#(mark(X)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(tail(X)) -> mark#(X) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(head(X)) -> active#(head(mark(X))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(head(X)) -> head#(mark(X)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(head(X)) -> mark#(X) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(0()) -> active#(0()) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(nats()) -> active#(nats()) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(adx(X)) -> active#(adx(mark(X))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(adx(X)) -> adx#(mark(X)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(adx(X)) -> mark#(X) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(s(X)) -> active#(s(mark(X))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(s(X)) -> s#(mark(X)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(s(X)) -> mark#(X) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> mark#(X1) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(nil()) -> active#(nil()) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(incr(X)) -> incr#(mark(X)) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(incr(X)) -> mark#(X) active#(zeros()) -> cons#(0(),zeros()) -> cons#(active(X1),X2) -> cons#(X1,X2) active#(zeros()) -> cons#(0(),zeros()) -> cons#(mark(X1),X2) -> cons#(X1,X2) active#(adx(cons(X,L))) -> adx#(L) -> adx#(active(X)) -> adx#(X) active#(adx(cons(X,L))) -> adx#(L) -> adx#(mark(X)) -> adx#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(tail(X)) -> active#(tail(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(tail(X)) -> tail#(mark(X)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(tail(X)) -> mark#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(head(X)) -> active#(head(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(head(X)) -> head#(mark(X)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(head(X)) -> mark#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(0()) -> active#(0()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(zeros()) -> active#(zeros()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(nats()) -> active#(nats()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(adx(X)) -> adx#(mark(X)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(adx(X)) -> mark#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(s(X)) -> active#(s(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(s(X)) -> s#(mark(X)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(s(X)) -> mark#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(cons(X1,X2)) -> mark#(X1) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(nil()) -> active#(nil()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(incr(X)) -> incr#(mark(X)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(incr(X)) -> mark#(X) active#(adx(cons(X,L))) -> cons#(X,adx(L)) -> cons#(active(X1),X2) -> cons#(X1,X2) active#(adx(cons(X,L))) -> cons#(X,adx(L)) -> cons#(mark(X1),X2) -> cons#(X1,X2) active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) -> incr#(active(X)) -> incr#(X) active#(adx(cons(X,L))) -> incr#(cons(X,adx(L))) -> incr#(mark(X)) -> incr#(X) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(tail(X)) -> active#(tail(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(tail(X)) -> tail#(mark(X)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(tail(X)) -> mark#(X) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(head(X)) -> active#(head(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(head(X)) -> head#(mark(X)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(head(X)) -> mark#(X) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(0()) -> active#(0()) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(zeros()) -> active#(zeros()) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(nats()) -> active#(nats()) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(adx(X)) -> active#(adx(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(adx(X)) -> adx#(mark(X)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(adx(X)) -> mark#(X) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(s(X)) -> active#(s(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(s(X)) -> s#(mark(X)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(s(X)) -> mark#(X) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(cons(X1,X2)) -> mark#(X1) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(nil()) -> active#(nil()) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(incr(X)) -> incr#(mark(X)) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(incr(X)) -> mark#(X) active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) -> cons#(active(X1),X2) -> cons#(X1,X2) active#(incr(cons(X,L))) -> cons#(s(X),incr(L)) -> cons#(mark(X1),X2) -> cons#(X1,X2) active#(incr(cons(X,L))) -> s#(X) -> s#(active(X)) -> s#(X) active#(incr(cons(X,L))) -> s#(X) -> s#(mark(X)) -> s#(X) active#(incr(cons(X,L))) -> incr#(L) -> incr#(active(X)) -> incr#(X) active#(incr(cons(X,L))) -> incr#(L) -> incr#(mark(X)) -> incr#(X) SCC Processor: #sccs: 7 #rules: 31 #arcs: 348/1936 DPs: mark#(tail(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(nil()) -> active#(nil()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(zeros()) -> mark#(cons(0(),zeros())) mark#(s(X)) -> mark#(X) mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) mark#(nats()) -> active#(nats()) mark#(zeros()) -> active#(zeros()) mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> active#(tail(mark(X))) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) EDG Processor: DPs: mark#(tail(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(nil()) -> active#(nil()) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(zeros()) -> mark#(cons(0(),zeros())) mark#(s(X)) -> mark#(X) mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) mark#(nats()) -> active#(nats()) mark#(zeros()) -> active#(zeros()) mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> active#(tail(mark(X))) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) graph: mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(tail(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(tail(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(tail(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(tail(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(tail(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(head(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(head(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(head(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(head(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(head(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(head(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(head(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(head(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(zeros()) -> active#(zeros()) -> active#(zeros()) -> mark#(cons(0(),zeros())) mark#(adx(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(adx(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(adx(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(adx(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(adx(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(adx(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(adx(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(adx(X)) -> active#(adx(mark(X))) -> active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(s(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(s(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(adx(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nats()) -> active#(nats()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(head(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(head(X)) -> active#(head(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(incr(X)) -> active#(incr(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(incr(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(adx(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(adx(X)) -> active#(adx(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(nats()) -> active#(nats()) mark#(incr(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(incr(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(incr(X)) -> mark#(X) -> mark#(head(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(head(X)) -> active#(head(mark(X))) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) -> mark#(tail(X)) -> active#(tail(mark(X))) mark#(incr(X)) -> active#(incr(mark(X))) -> active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> mark#(X1) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(incr(X)) -> mark#(X) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) -> mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(cons(X1,X2)) -> mark#(X1) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) SCC Processor: #sccs: 1 #rules: 12 #arcs: 105/361 DPs: mark#(tail(X)) -> mark#(X) mark#(head(X)) -> mark#(X) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(incr(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Bounds Processor: bound: 0 enrichment: match-dp automaton: final states: {7} transitions: zeros0() -> 8* cons0(9,8) -> 10* 00() -> 9* mark{#,0}(10) -> 7* mark{#,0}(9) -> 7* problem: DPs: mark#(tail(X)) -> mark#(X) mark#(head(X)) -> mark#(X) mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(incr(X)) -> mark#(X) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) SCC Processor: #sccs: 1 #rules: 10 #arcs: 61/121 DPs: mark#(tail(X)) -> mark#(X) mark#(head(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Semantic Labeling Processor: dimension: 1 usable rules: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) interpretation: [tail](x0) = x0, [head](x0) = 1, [0] = 0, [zeros] = 0, [nats] = 0, [adx](x0) = 0, [s](x0) = x0, [cons](x0, x1) = x1, [mark](x0) = x0, [active](x0) = x0, [incr](x0) = x0, [nil] = 0 labeled: mark# mark zeros 0 usable (for model): mark# tail head adx active# mark cons incr s active zeros 0 nil nats argument filtering: pi(nil) = [] pi(incr) = 0 pi(active) = 0 pi(mark) = 0 pi(cons) = 0 pi(s) = 0 pi(adx) = 0 pi(nats) = [] pi(zeros) = [] pi(0) = [] pi(head) = [0] pi(tail) = 0 pi(active#) = 0 pi(mark#) = 0 precedence: zeros > mark# ~ active# ~ tail ~ head ~ 0 ~ nats ~ adx ~ s ~ cons ~ mark ~ active ~ incr ~ nil problem: DPs: mark#(tail(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Restore Modifier: DPs: mark#(tail(X)) -> mark#(X) mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Semantic Labeling Processor: dimension: 1 usable rules: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) interpretation: [tail](x0) = x0, [head](x0) = 0, [0] = 0, [zeros] = 0, [nats] = 0, [adx](x0) = 0, [s](x0) = 0, [cons](x0, x1) = x1, [mark](x0) = 0, [active](x0) = 1, [incr](x0) = 0, [nil] = 0 labeled: zeros 0 usable (for model): zeros 0 argument filtering: pi(nil) = [] pi(incr) = 0 pi(active) = 0 pi(mark) = 0 pi(cons) = 0 pi(s) = 0 pi(adx) = 0 pi(nats) = [] pi(zeros) = [] pi(0) = [] pi(head) = 0 pi(tail) = [0] pi(active#) = 0 pi(mark#) = 0 precedence: zeros > mark# ~ active# ~ tail ~ head ~ 0 ~ nats ~ adx ~ s ~ cons ~ mark ~ active ~ incr ~ nil problem: DPs: mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Restore Modifier: DPs: mark#(adx(X)) -> active#(adx(mark(X))) active#(adx(cons(X,L))) -> mark#(incr(cons(X,adx(L)))) mark#(incr(X)) -> active#(incr(mark(X))) active#(incr(cons(X,L))) -> mark#(cons(s(X),incr(L))) mark#(cons(X1,X2)) -> mark#(X1) mark#(adx(X)) -> mark#(X) mark#(s(X)) -> mark#(X) mark#(incr(X)) -> mark#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) KBO Processor: argument filtering: pi(nil) = [] pi(incr) = [0] pi(active) = 0 pi(mark) = 0 pi(cons) = 0 pi(s) = [0] pi(adx) = [0] pi(nats) = [] pi(zeros) = [] pi(0) = [] pi(head) = [] pi(tail) = [] pi(active#) = 0 pi(mark#) = 0 usable rules: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) weight function: w0 = 1 w(mark#) = w(active#) = w(tail) = w(head) = w(0) = w( zeros) = w(nats) = w(adx) = w(s) = w(cons) = w(mark) = w( active) = w(incr) = w(nil) = 1 precedence: adx > incr > zeros > mark# ~ active# ~ tail ~ head ~ 0 ~ nats ~ s ~ cons ~ mark ~ active ~ nil problem: DPs: mark#(adx(X)) -> active#(adx(mark(X))) mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Restore Modifier: DPs: mark#(adx(X)) -> active#(adx(mark(X))) mark#(incr(X)) -> active#(incr(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) SCC Processor: #sccs: 1 #rules: 1 #arcs: 53/9 DPs: mark#(cons(X1,X2)) -> mark#(X1) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Bounds Processor: bound: 0 enrichment: match-dp automaton: final states: {1} transitions: mark{#,0}(2) -> 1* f1670() -> 2* problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(cons#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(s#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: incr#(mark(X)) -> incr#(X) incr#(active(X)) -> incr#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(incr#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: adx#(mark(X)) -> adx#(X) adx#(active(X)) -> adx#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(adx#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: head#(mark(X)) -> head#(X) head#(active(X)) -> head#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(head#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed DPs: tail#(mark(X)) -> tail#(X) tail#(active(X)) -> tail#(X) TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Subterm Criterion Processor: simple projection: pi(tail#) = 0 problem: DPs: TRS: active(incr(cons(X,L))) -> mark(cons(s(X),incr(L))) active(adx(cons(X,L))) -> mark(incr(cons(X,adx(L)))) active(zeros()) -> mark(cons(0(),zeros())) mark(incr(X)) -> active(incr(mark(X))) mark(nil()) -> active(nil()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(s(X)) -> active(s(mark(X))) mark(adx(X)) -> active(adx(mark(X))) mark(nats()) -> active(nats()) mark(zeros()) -> active(zeros()) mark(0()) -> active(0()) mark(head(X)) -> active(head(mark(X))) mark(tail(X)) -> active(tail(mark(X))) incr(mark(X)) -> incr(X) incr(active(X)) -> incr(X) cons(mark(X1),X2) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) s(mark(X)) -> s(X) s(active(X)) -> s(X) adx(mark(X)) -> adx(X) adx(active(X)) -> adx(X) head(mark(X)) -> head(X) head(active(X)) -> head(X) tail(mark(X)) -> tail(X) tail(active(X)) -> tail(X) Qed