MAYBE Problem: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Proof: DP Processor: DPs: active#(zeros()) -> cons#(0(),zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) active#(and(tt(),X)) -> mark#(X) active#(length(nil())) -> mark#(0()) active#(length(cons(N,L))) -> length#(L) active#(length(cons(N,L))) -> s#(length(L)) active#(length(cons(N,L))) -> mark#(s(length(L))) active#(take(0(),IL)) -> mark#(nil()) active#(take(s(M),cons(N,IL))) -> take#(M,IL) active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(0()) -> active#(0()) mark#(and(X1,X2)) -> mark#(X1) mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(tt()) -> active#(tt()) mark#(length(X)) -> mark#(X) mark#(length(X)) -> length#(mark(X)) mark#(length(X)) -> active#(length(mark(X))) mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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) and#(mark(X1),X2) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) length#(mark(X)) -> length#(X) length#(active(X)) -> length#(X) s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) take#(mark(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) EDG Processor: DPs: active#(zeros()) -> cons#(0(),zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) active#(and(tt(),X)) -> mark#(X) active#(length(nil())) -> mark#(0()) active#(length(cons(N,L))) -> length#(L) active#(length(cons(N,L))) -> s#(length(L)) active#(length(cons(N,L))) -> mark#(s(length(L))) active#(take(0(),IL)) -> mark#(nil()) active#(take(s(M),cons(N,IL))) -> take#(M,IL) active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(0()) -> active#(0()) mark#(and(X1,X2)) -> mark#(X1) mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(tt()) -> active#(tt()) mark#(length(X)) -> mark#(X) mark#(length(X)) -> length#(mark(X)) mark#(length(X)) -> active#(length(mark(X))) mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) 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) and#(mark(X1),X2) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) length#(mark(X)) -> length#(X) length#(active(X)) -> length#(X) s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) take#(mark(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) graph: and#(mark(X1),X2) -> and#(X1,X2) -> and#(mark(X1),X2) -> and#(X1,X2) and#(mark(X1),X2) -> and#(X1,X2) -> and#(X1,mark(X2)) -> and#(X1,X2) and#(mark(X1),X2) -> and#(X1,X2) -> and#(active(X1),X2) -> and#(X1,X2) and#(mark(X1),X2) -> and#(X1,X2) -> and#(X1,active(X2)) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) -> and#(mark(X1),X2) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) -> and#(X1,mark(X2)) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) -> and#(active(X1),X2) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) -> and#(X1,active(X2)) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) -> and#(mark(X1),X2) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) -> and#(X1,mark(X2)) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) -> and#(active(X1),X2) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) -> and#(X1,active(X2)) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) -> and#(mark(X1),X2) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) -> and#(X1,mark(X2)) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) -> and#(active(X1),X2) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) -> and#(X1,active(X2)) -> and#(X1,X2) take#(mark(X1),X2) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(mark(X1),X2) -> take#(X1,X2) -> take#(X1,mark(X2)) -> take#(X1,X2) take#(mark(X1),X2) -> take#(X1,X2) -> take#(active(X1),X2) -> take#(X1,X2) take#(mark(X1),X2) -> take#(X1,X2) -> take#(X1,active(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(X1,mark(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(active(X1),X2) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) -> take#(X1,active(X2)) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(X1,mark(X2)) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(active(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) -> take#(X1,active(X2)) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(mark(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(X1,mark(X2)) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(active(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) -> take#(X1,active(X2)) -> take#(X1,X2) s#(mark(X)) -> s#(X) -> s#(mark(X)) -> s#(X) s#(mark(X)) -> s#(X) -> s#(active(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) -> s#(active(X)) -> s#(X) length#(mark(X)) -> length#(X) -> length#(mark(X)) -> length#(X) length#(mark(X)) -> length#(X) -> length#(active(X)) -> length#(X) length#(active(X)) -> length#(X) -> length#(mark(X)) -> length#(X) length#(active(X)) -> length#(X) -> length#(active(X)) -> length#(X) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(mark(X1),X2) -> take#(X1,X2) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(X1,mark(X2)) -> take#(X1,X2) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(active(X1),X2) -> take#(X1,X2) mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) -> take#(X1,active(X2)) -> take#(X1,X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(zeros()) -> active#(zeros()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(0()) -> active#(0()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(and(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(tt()) -> active#(tt()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(length(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(length(X)) -> length#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(length(X)) -> active#(length(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(nil()) -> active#(nil()) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> s#(mark(X)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> mark#(X2) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(zeros()) -> active#(zeros()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> length#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> active#(length(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X1) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(take(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(and(tt(),X)) -> mark#(X) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(length(nil())) -> mark#(0()) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(length(cons(N,L))) -> length#(L) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(length(cons(N,L))) -> s#(length(L)) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(take(0(),IL)) -> mark#(nil()) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(take(s(M),cons(N,IL))) -> take#(M,IL) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) -> active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(s(X)) -> s#(mark(X)) -> s#(mark(X)) -> s#(X) mark#(s(X)) -> s#(mark(X)) -> s#(active(X)) -> s#(X) mark#(s(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(s(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(s(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(s(X)) -> mark#(X) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(s(X)) -> mark#(X) -> mark#(tt()) -> active#(tt()) mark#(s(X)) -> mark#(X) -> mark#(length(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(length(X)) -> length#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(length(X)) -> active#(length(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(s(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(s(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(s(X)) -> active#(s(mark(X))) -> active#(and(tt(),X)) -> mark#(X) mark#(s(X)) -> active#(s(mark(X))) -> active#(length(nil())) -> mark#(0()) mark#(s(X)) -> active#(s(mark(X))) -> active#(length(cons(N,L))) -> length#(L) mark#(s(X)) -> active#(s(mark(X))) -> active#(length(cons(N,L))) -> s#(length(L)) mark#(s(X)) -> active#(s(mark(X))) -> active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> active#(s(mark(X))) -> active#(take(0(),IL)) -> mark#(nil()) mark#(s(X)) -> active#(s(mark(X))) -> active#(take(s(M),cons(N,IL))) -> take#(M,IL) mark#(s(X)) -> active#(s(mark(X))) -> active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) mark#(s(X)) -> active#(s(mark(X))) -> active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(length(X)) -> length#(mark(X)) -> length#(mark(X)) -> length#(X) mark#(length(X)) -> length#(mark(X)) -> length#(active(X)) -> length#(X) mark#(length(X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) mark#(length(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(length(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(length(X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(length(X)) -> mark#(X) -> mark#(0()) -> active#(0()) mark#(length(X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1) mark#(length(X)) -> mark#(X) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(length(X)) -> mark#(X) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(length(X)) -> mark#(X) -> mark#(tt()) -> active#(tt()) mark#(length(X)) -> mark#(X) -> mark#(length(X)) -> mark#(X) mark#(length(X)) -> mark#(X) -> mark#(length(X)) -> length#(mark(X)) mark#(length(X)) -> mark#(X) -> mark#(length(X)) -> active#(length(mark(X))) mark#(length(X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) mark#(length(X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) mark#(length(X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) mark#(length(X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) mark#(length(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) mark#(length(X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) mark#(length(X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(length(X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(length(X)) -> active#(length(mark(X))) -> active#(and(tt(),X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) -> active#(length(nil())) -> mark#(0()) mark#(length(X)) -> active#(length(mark(X))) -> active#(length(cons(N,L))) -> length#(L) mark#(length(X)) -> active#(length(mark(X))) -> active#(length(cons(N,L))) -> s#(length(L)) mark#(length(X)) -> active#(length(mark(X))) -> active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(length(X)) -> active#(length(mark(X))) -> active#(take(0(),IL)) -> mark#(nil()) mark#(length(X)) -> active#(length(mark(X))) -> active#(take(s(M),cons(N,IL))) -> take#(M,IL) mark#(length(X)) -> active#(length(mark(X))) -> active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) mark#(length(X)) -> active#(length(mark(X))) -> active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(and(X1,X2)) -> and#(mark(X1),X2) -> and#(mark(X1),X2) -> and#(X1,X2) mark#(and(X1,X2)) -> and#(mark(X1),X2) -> and#(active(X1),X2) -> and#(X1,X2) mark#(and(X1,X2)) -> mark#(X1) -> mark#(zeros()) -> active#(zeros()) mark#(and(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(and(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(and(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(and(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(and(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> mark#(X1) mark#(and(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(and(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(and(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt()) mark#(and(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> mark#(X) mark#(and(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> length#(mark(X)) mark#(and(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> active#(length(mark(X))) mark#(and(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(and(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(and(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(and(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X1) mark#(and(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(and(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(and(tt(),X)) -> mark#(X) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(length(nil())) -> mark#(0()) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(length(cons(N,L))) -> length#(L) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(length(cons(N,L))) -> s#(length(L)) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(take(0(),IL)) -> mark#(nil()) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> take#(M,IL) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(zeros()) -> active#(zeros()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(0()) -> active#(0()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(tt()) -> active#(tt()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> length#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(length(X)) -> active#(length(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(nil()) -> active#(nil()) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> s#(mark(X)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(s(X)) -> active#(s(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X2) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) mark#(cons(X1,X2)) -> mark#(X1) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> cons#(mark(X1),X2) -> cons#(active(X1),X2) -> cons#(X1,X2) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(and(tt(),X)) -> mark#(X) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(length(nil())) -> mark#(0()) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(length(cons(N,L))) -> length#(L) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(length(cons(N,L))) -> s#(length(L)) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(take(0(),IL)) -> mark#(nil()) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> take#(M,IL) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) -> active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(zeros()) -> active#(zeros()) -> active#(zeros()) -> cons#(0(),zeros()) mark#(zeros()) -> active#(zeros()) -> active#(zeros()) -> mark#(cons(0(),zeros())) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(X1,mark(X2)) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) -> cons#(X1,active(X2)) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) -> cons#(X1,mark(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#(X1,active(X2)) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) -> cons#(X1,mark(X2)) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) -> cons#(X1,active(X2)) -> cons#(X1,X2) cons#(X1,active(X2)) -> cons#(X1,X2) -> cons#(mark(X1),X2) -> cons#(X1,X2) cons#(X1,active(X2)) -> cons#(X1,X2) -> cons#(X1,mark(X2)) -> cons#(X1,X2) cons#(X1,active(X2)) -> cons#(X1,X2) -> cons#(active(X1),X2) -> cons#(X1,X2) cons#(X1,active(X2)) -> cons#(X1,X2) -> cons#(X1,active(X2)) -> cons#(X1,X2) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(cons(X1,X2)) -> mark#(X1) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(and(X1,X2)) -> mark#(X1) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(length(X)) -> mark#(X) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(length(X)) -> length#(mark(X)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(length(X)) -> active#(length(mark(X))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(s(X)) -> mark#(X) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(s(X)) -> s#(mark(X)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(s(X)) -> active#(s(mark(X))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(take(X1,X2)) -> mark#(X2) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(take(X1,X2)) -> mark#(X1) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) -> cons#(X1,mark(X2)) -> cons#(X1,X2) active#(take(s(M),cons(N,IL))) -> cons#(N,take(M,IL)) -> cons#(X1,active(X2)) -> cons#(X1,X2) active#(take(0(),IL)) -> mark#(nil()) -> mark#(nil()) -> active#(nil()) active#(length(nil())) -> mark#(0()) -> mark#(0()) -> active#(0()) active#(length(cons(N,L))) -> s#(length(L)) -> s#(mark(X)) -> s#(X) active#(length(cons(N,L))) -> s#(length(L)) -> s#(active(X)) -> s#(X) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(cons(X1,X2)) -> mark#(X1) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(and(X1,X2)) -> mark#(X1) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(length(X)) -> mark#(X) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(length(X)) -> length#(mark(X)) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(length(X)) -> active#(length(mark(X))) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(s(X)) -> mark#(X) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(s(X)) -> s#(mark(X)) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(s(X)) -> active#(s(mark(X))) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(take(X1,X2)) -> mark#(X2) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(take(X1,X2)) -> mark#(X1) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) active#(length(cons(N,L))) -> mark#(s(length(L))) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(and(tt(),X)) -> mark#(X) -> mark#(zeros()) -> active#(zeros()) active#(and(tt(),X)) -> mark#(X) -> mark#(cons(X1,X2)) -> mark#(X1) active#(and(tt(),X)) -> mark#(X) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(and(tt(),X)) -> mark#(X) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) active#(and(tt(),X)) -> mark#(X) -> mark#(0()) -> active#(0()) active#(and(tt(),X)) -> mark#(X) -> mark#(and(X1,X2)) -> mark#(X1) active#(and(tt(),X)) -> mark#(X) -> mark#(and(X1,X2)) -> and#(mark(X1),X2) active#(and(tt(),X)) -> mark#(X) -> mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) active#(and(tt(),X)) -> mark#(X) -> mark#(tt()) -> active#(tt()) active#(and(tt(),X)) -> mark#(X) -> mark#(length(X)) -> mark#(X) active#(and(tt(),X)) -> mark#(X) -> mark#(length(X)) -> length#(mark(X)) active#(and(tt(),X)) -> mark#(X) -> mark#(length(X)) -> active#(length(mark(X))) active#(and(tt(),X)) -> mark#(X) -> mark#(nil()) -> active#(nil()) active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> mark#(X) active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> s#(mark(X)) active#(and(tt(),X)) -> mark#(X) -> mark#(s(X)) -> active#(s(mark(X))) active#(and(tt(),X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X2) active#(and(tt(),X)) -> mark#(X) -> mark#(take(X1,X2)) -> mark#(X1) active#(and(tt(),X)) -> mark#(X) -> mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) active#(and(tt(),X)) -> mark#(X) -> mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> mark#(X1) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> cons#(mark(X1),X2) active#(zeros()) -> mark#(cons(0(),zeros())) -> mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) SCC Processor: #sccs: 6 #rules: 32 #arcs: 296/2209 DPs: mark#(take(X1,X2)) -> mark#(X2) mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(take(X1,X2)) -> mark#(X1) mark#(s(X)) -> active#(s(mark(X))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) active#(and(tt(),X)) -> mark#(X) mark#(length(X)) -> mark#(X) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(and(X1,X2)) -> mark#(X1) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = x0 + 1, [active#](x0) = x0 + 1, [take](x0, x1) = x0 + x1 + 1, [s](x0) = x0, [length](x0) = x0, [nil] = 1, [and](x0, x1) = x0 + x1 + 1, [tt] = 0, [mark](x0) = x0, [cons](x0, x1) = x0 + x1, [0] = 0, [active](x0) = x0, [zeros] = 0 orientation: mark#(take(X1,X2)) = X1 + X2 + 2 >= X2 + 1 = mark#(X2) mark#(take(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = IL + M + N + 2 >= IL + M + N + 2 = mark#(cons(N,take(M,IL))) mark#(take(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = mark#(X1) mark#(s(X)) = X + 1 >= X + 1 = active#(s(mark(X))) active#(length(cons(N,L))) = L + N + 1 >= L + 1 = mark#(s(length(L))) mark#(s(X)) = X + 1 >= X + 1 = mark#(X) mark#(length(X)) = X + 1 >= X + 1 = active#(length(mark(X))) active#(and(tt(),X)) = X + 2 >= X + 1 = mark#(X) mark#(length(X)) = X + 1 >= X + 1 = mark#(X) mark#(and(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = active#(and(mark(X1),X2)) mark#(and(X1,X2)) = X1 + X2 + 2 >= X1 + 1 = mark#(X1) mark#(cons(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) = X1 + X2 + 1 >= X1 + 1 = mark#(X1) mark#(zeros()) = 1 >= 1 = active#(zeros()) active#(zeros()) = 1 >= 1 = mark#(cons(0(),zeros())) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X = mark(X) active(length(nil())) = 1 >= 0 = mark(0()) active(length(cons(N,L))) = L + N >= L = mark(s(length(L))) active(take(0(),IL)) = IL + 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = IL + M + N + 1 >= IL + M + N + 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 0 >= 0 = active(zeros()) mark(cons(X1,X2)) = X1 + X2 >= X1 + X2 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = X >= X = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,mark(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(active(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,active(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) and(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) length(mark(X)) = X >= X = length(X) length(active(X)) = X >= X = length(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,X2) take(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,X2) take(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,X2) take(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(s(X)) -> active#(s(mark(X))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(length(X)) -> mark#(X) mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = 1, [active#](x0) = x0, [take](x0, x1) = 1, [s](x0) = 1, [length](x0) = 1, [nil] = 0, [and](x0, x1) = 0, [tt] = 0, [mark](x0) = 1, [cons](x0, x1) = 1, [0] = 0, [active](x0) = 1, [zeros] = 1 orientation: mark#(take(X1,X2)) = 1 >= 1 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = 1 >= 1 = mark#(cons(N,take(M,IL))) mark#(s(X)) = 1 >= 1 = active#(s(mark(X))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = 1 >= 1 = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) mark#(length(X)) = 1 >= 1 = mark#(X) mark#(and(X1,X2)) = 1 >= 0 = active#(and(mark(X1),X2)) mark#(cons(X1,X2)) = 1 >= 1 = active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) = 1 >= 1 = mark#(X1) mark#(zeros()) = 1 >= 1 = active#(zeros()) active#(zeros()) = 1 >= 1 = mark#(cons(0(),zeros())) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = 1 >= 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,mark(X2)) = 1 >= 1 = cons(X1,X2) cons(active(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,active(X2)) = 1 >= 1 = cons(X1,X2) and(mark(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,mark(X2)) = 0 >= 0 = and(X1,X2) and(active(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,active(X2)) = 0 >= 0 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 1 >= 1 = s(X) s(active(X)) = 1 >= 1 = s(X) take(mark(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,mark(X2)) = 1 >= 1 = take(X1,X2) take(active(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,active(X2)) = 1 >= 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) mark#(s(X)) -> active#(s(mark(X))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(length(X)) -> mark#(X) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = 1, [active#](x0) = x0, [take](x0, x1) = 1, [s](x0) = 0, [length](x0) = 1, [nil] = 1, [and](x0, x1) = 1, [tt] = 0, [mark](x0) = 1, [cons](x0, x1) = 1, [0] = 1, [active](x0) = x0, [zeros] = 1 orientation: mark#(take(X1,X2)) = 1 >= 1 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = 1 >= 1 = mark#(cons(N,take(M,IL))) mark#(s(X)) = 1 >= 0 = active#(s(mark(X))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = 1 >= 1 = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) mark#(length(X)) = 1 >= 1 = mark#(X) mark#(cons(X1,X2)) = 1 >= 1 = active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) = 1 >= 1 = mark#(X1) mark#(zeros()) = 1 >= 1 = active#(zeros()) active#(zeros()) = 1 >= 1 = mark#(cons(0(),zeros())) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = 1 >= 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 0 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,mark(X2)) = 1 >= 1 = cons(X1,X2) cons(active(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,active(X2)) = 1 >= 1 = cons(X1,X2) and(mark(X1),X2) = 1 >= 1 = and(X1,X2) and(X1,mark(X2)) = 1 >= 1 = and(X1,X2) and(active(X1),X2) = 1 >= 1 = and(X1,X2) and(X1,active(X2)) = 1 >= 1 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,mark(X2)) = 1 >= 1 = take(X1,X2) take(active(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,active(X2)) = 1 >= 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(length(X)) -> mark#(X) mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = 1, [active#](x0) = x0, [take](x0, x1) = 1, [s](x0) = 0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = 0, [tt] = 0, [mark](x0) = 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = 1, [zeros] = 1 orientation: mark#(take(X1,X2)) = 1 >= 1 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = 1 >= 1 = mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = 1 >= 1 = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) mark#(length(X)) = 1 >= 1 = mark#(X) mark#(cons(X1,X2)) = 1 >= 0 = active#(cons(mark(X1),X2)) mark#(cons(X1,X2)) = 1 >= 1 = mark#(X1) mark#(zeros()) = 1 >= 1 = active#(zeros()) active#(zeros()) = 1 >= 1 = mark#(cons(0(),zeros())) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = 1 >= 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,mark(X2)) = 0 >= 0 = and(X1,X2) and(active(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,active(X2)) = 0 >= 0 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,mark(X2)) = 1 >= 1 = take(X1,X2) take(active(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,active(X2)) = 1 >= 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(length(X)) -> mark#(X) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = x0, [active#](x0) = x0, [take](x0, x1) = x1 + 1, [s](x0) = x0, [length](x0) = x0 + 1, [nil] = 0, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0, [cons](x0, x1) = x0 + x1, [0] = 0, [active](x0) = x0, [zeros] = 0 orientation: mark#(take(X1,X2)) = X2 + 1 >= X2 + 1 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = IL + N + 1 >= IL + N + 1 = mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) = L + N + 1 >= L + 1 = mark#(s(length(L))) mark#(s(X)) = X >= X = mark#(X) mark#(length(X)) = X + 1 >= X + 1 = active#(length(mark(X))) mark#(length(X)) = X + 1 >= X = mark#(X) mark#(cons(X1,X2)) = X1 + X2 >= X1 = mark#(X1) mark#(zeros()) = 0 >= 0 = active#(zeros()) active#(zeros()) = 0 >= 0 = mark#(cons(0(),zeros())) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = X >= X = mark(X) active(length(nil())) = 1 >= 0 = mark(0()) active(length(cons(N,L))) = L + N + 1 >= L + 1 = mark(s(length(L))) active(take(0(),IL)) = IL + 1 >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = IL + N + 1 >= IL + N + 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 0 >= 0 = active(zeros()) mark(cons(X1,X2)) = X1 + X2 >= X1 + X2 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = X2 >= X2 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = X + 1 >= X + 1 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X2 + 1 >= X2 + 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,mark(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(active(X1),X2) = X1 + X2 >= X1 + X2 = cons(X1,X2) cons(X1,active(X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 >= X2 = and(X1,X2) length(mark(X)) = X + 1 >= X + 1 = length(X) length(active(X)) = X + 1 >= X + 1 = length(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,mark(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) take(active(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,active(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) -> mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = x0, [active#](x0) = x0, [take](x0, x1) = x1 + 1, [s](x0) = x0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0, [cons](x0, x1) = x0, [0] = 0, [active](x0) = x0, [zeros] = 0 orientation: mark#(take(X1,X2)) = X2 + 1 >= X2 + 1 = active#(take(mark(X1),mark(X2))) active#(take(s(M),cons(N,IL))) = N + 1 >= N = mark#(cons(N,take(M,IL))) active#(length(cons(N,L))) = 0 >= 0 = mark#(s(length(L))) mark#(s(X)) = X >= X = mark#(X) mark#(length(X)) = 0 >= 0 = active#(length(mark(X))) mark#(cons(X1,X2)) = X1 >= X1 = mark#(X1) mark#(zeros()) = 0 >= 0 = active#(zeros()) active#(zeros()) = 0 >= 0 = mark#(cons(0(),zeros())) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = X >= X = mark(X) active(length(nil())) = 0 >= 0 = mark(0()) active(length(cons(N,L))) = 0 >= 0 = mark(s(length(L))) active(take(0(),IL)) = IL + 1 >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = N + 1 >= N = mark(cons(N,take(M,IL))) mark(zeros()) = 0 >= 0 = active(zeros()) mark(cons(X1,X2)) = X1 >= X1 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = X2 >= X2 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = 0 >= 0 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X2 + 1 >= X2 + 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = X1 >= X1 = cons(X1,X2) cons(X1,mark(X2)) = X1 >= X1 = cons(X1,X2) cons(active(X1),X2) = X1 >= X1 = cons(X1,X2) cons(X1,active(X2)) = X1 >= X1 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 >= X2 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,mark(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) take(active(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,active(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) active#(zeros()) -> mark#(cons(0(),zeros())) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = x0, [active#](x0) = 1, [take](x0, x1) = x1 + 1, [s](x0) = x0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0, [cons](x0, x1) = x0, [0] = 0, [active](x0) = x0, [zeros] = 1 orientation: mark#(take(X1,X2)) = X2 + 1 >= 1 = active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = X >= X = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) mark#(cons(X1,X2)) = X1 >= X1 = mark#(X1) mark#(zeros()) = 1 >= 1 = active#(zeros()) active#(zeros()) = 1 >= 0 = mark#(cons(0(),zeros())) active(zeros()) = 1 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = X >= X = mark(X) active(length(nil())) = 1 >= 0 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = IL + 1 >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = N + 1 >= N = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = X1 >= X1 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = X2 >= X2 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X2 + 1 >= X2 + 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = X1 >= X1 = cons(X1,X2) cons(X1,mark(X2)) = X1 >= X1 = cons(X1,X2) cons(active(X1),X2) = X1 >= X1 = cons(X1,X2) cons(X1,active(X2)) = X1 >= X1 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 >= X2 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,mark(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) take(active(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,active(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) mark#(zeros()) -> active#(zeros()) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = 1, [active#](x0) = x0, [take](x0, x1) = 1, [s](x0) = 0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = 0, [tt] = 0, [mark](x0) = 0, [cons](x0, x1) = 0, [0] = 0, [active](x0) = 0, [zeros] = 0 orientation: mark#(take(X1,X2)) = 1 >= 1 = active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = 1 >= 1 = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) mark#(cons(X1,X2)) = 1 >= 1 = mark#(X1) mark#(zeros()) = 1 >= 0 = active#(zeros()) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = 0 >= 0 = mark(X) active(length(nil())) = 0 >= 0 = mark(0()) active(length(cons(N,L))) = 0 >= 0 = mark(s(length(L))) active(take(0(),IL)) = 0 >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = 0 >= 0 = mark(cons(N,take(M,IL))) mark(zeros()) = 0 >= 0 = active(zeros()) mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = 0 >= 0 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = 0 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = 0 >= 0 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,mark(X2)) = 0 >= 0 = and(X1,X2) and(active(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,active(X2)) = 0 >= 0 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,mark(X2)) = 1 >= 1 = take(X1,X2) take(active(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,active(X2)) = 1 >= 1 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) mark#(cons(X1,X2)) -> mark#(X1) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = x0, [active#](x0) = 0, [take](x0, x1) = x1, [s](x0) = x0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = x0 + x1 + 1, [tt] = 1, [mark](x0) = x0, [cons](x0, x1) = x0 + 1, [0] = 0, [active](x0) = x0, [zeros] = 1 orientation: mark#(take(X1,X2)) = X2 >= 0 = active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) = 0 >= 0 = mark#(s(length(L))) mark#(s(X)) = X >= X = mark#(X) mark#(length(X)) = 0 >= 0 = active#(length(mark(X))) mark#(cons(X1,X2)) = X1 + 1 >= X1 = mark#(X1) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 2 >= X = mark(X) active(length(nil())) = 0 >= 0 = mark(0()) active(length(cons(N,L))) = 0 >= 0 = mark(s(length(L))) active(take(0(),IL)) = IL >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = N + 1 >= N + 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = X1 + 1 >= X1 + 1 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 0 >= 0 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = X >= X = active(s(mark(X))) mark(take(X1,X2)) = X2 >= X2 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2) cons(X1,mark(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2) cons(active(X1),X2) = X1 + 1 >= X1 + 1 = cons(X1,X2) cons(X1,active(X2)) = X1 + 1 >= X1 + 1 = cons(X1,X2) and(mark(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,mark(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = X >= X = s(X) s(active(X)) = X >= X = s(X) take(mark(X1),X2) = X2 >= X2 = take(X1,X2) take(X1,mark(X2)) = X2 >= X2 = take(X1,X2) take(active(X1),X2) = X2 >= X2 = take(X1,X2) take(X1,active(X2)) = X2 >= X2 = take(X1,X2) problem: DPs: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [mark#](x0) = 1, [active#](x0) = x0, [take](x0, x1) = 0, [s](x0) = 0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = 1, [tt] = 0, [mark](x0) = 0, [cons](x0, x1) = 0, [0] = 0, [active](x0) = 0, [zeros] = 0 orientation: mark#(take(X1,X2)) = 1 >= 0 = active#(take(mark(X1),mark(X2))) active#(length(cons(N,L))) = 1 >= 1 = mark#(s(length(L))) mark#(s(X)) = 1 >= 1 = mark#(X) mark#(length(X)) = 1 >= 1 = active#(length(mark(X))) active(zeros()) = 0 >= 0 = mark(cons(0(),zeros())) active(and(tt(),X)) = 0 >= 0 = mark(X) active(length(nil())) = 0 >= 0 = mark(0()) active(length(cons(N,L))) = 0 >= 0 = mark(s(length(L))) active(take(0(),IL)) = 0 >= 0 = mark(nil()) active(take(s(M),cons(N,IL))) = 0 >= 0 = mark(cons(N,take(M,IL))) mark(zeros()) = 0 >= 0 = active(zeros()) mark(cons(X1,X2)) = 0 >= 0 = active(cons(mark(X1),X2)) mark(0()) = 0 >= 0 = active(0()) mark(and(X1,X2)) = 0 >= 0 = active(and(mark(X1),X2)) mark(tt()) = 0 >= 0 = active(tt()) mark(length(X)) = 0 >= 0 = active(length(mark(X))) mark(nil()) = 0 >= 0 = active(nil()) mark(s(X)) = 0 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = 0 >= 0 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = 1 >= 1 = and(X1,X2) and(X1,mark(X2)) = 1 >= 1 = and(X1,X2) and(active(X1),X2) = 1 >= 1 = and(X1,X2) and(X1,active(X2)) = 1 >= 1 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,mark(X2)) = 0 >= 0 = take(X1,X2) take(active(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,active(X2)) = 0 >= 0 = take(X1,X2) problem: DPs: active#(length(cons(N,L))) -> mark#(s(length(L))) mark#(s(X)) -> mark#(X) mark#(length(X)) -> active#(length(mark(X))) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Open DPs: cons#(X1,active(X2)) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) cons#(mark(X1),X2) -> cons#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [cons#](x0, x1) = x0, [take](x0, x1) = x1 + 1, [s](x0) = 0, [length](x0) = x0 + 1, [nil] = 0, [and](x0, x1) = x0 + x1 + 1, [tt] = 1, [mark](x0) = x0 + 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0, [zeros] = 1 orientation: cons#(X1,active(X2)) = X1 >= X1 = cons#(X1,X2) cons#(active(X1),X2) = X1 >= X1 = cons#(X1,X2) cons#(X1,mark(X2)) = X1 >= X1 = cons#(X1,X2) cons#(mark(X1),X2) = X1 + 1 >= X1 = cons#(X1,X2) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 2 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = IL + 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 2 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 0 = active(0()) mark(and(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = active(and(mark(X1),X2)) mark(tt()) = 2 >= 1 = active(tt()) mark(length(X)) = X + 2 >= X + 2 = active(length(mark(X))) mark(nil()) = 1 >= 0 = active(nil()) mark(s(X)) = 1 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = X2 + 2 >= X2 + 2 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) length(mark(X)) = X + 2 >= X + 1 = length(X) length(active(X)) = X + 1 >= X + 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,mark(X2)) = X2 + 2 >= X2 + 1 = take(X1,X2) take(active(X1),X2) = X2 + 1 >= X2 + 1 = take(X1,X2) take(X1,active(X2)) = X2 + 1 >= X2 + 1 = take(X1,X2) problem: DPs: cons#(X1,active(X2)) -> cons#(X1,X2) cons#(active(X1),X2) -> cons#(X1,X2) cons#(X1,mark(X2)) -> cons#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [cons#](x0, x1) = x0 + x1 + 1, [take](x0, x1) = 1, [s](x0) = 0, [length](x0) = 0, [nil] = 1, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0 + 1, [cons](x0, x1) = 1, [0] = 0, [active](x0) = x0 + 1, [zeros] = 1 orientation: cons#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = cons#(X1,X2) cons#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = cons#(X1,X2) cons#(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = cons#(X1,X2) active(zeros()) = 2 >= 2 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 2 >= 2 = mark(nil()) active(take(s(M),cons(N,IL))) = 2 >= 2 = mark(cons(N,take(M,IL))) mark(zeros()) = 2 >= 2 = active(zeros()) mark(cons(X1,X2)) = 2 >= 2 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = X2 + 1 >= X2 + 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 2 >= 2 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 2 >= 2 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,mark(X2)) = 1 >= 1 = cons(X1,X2) cons(active(X1),X2) = 1 >= 1 = cons(X1,X2) cons(X1,active(X2)) = 1 >= 1 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 + 1 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 + 1 >= X2 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,mark(X2)) = 1 >= 1 = take(X1,X2) take(active(X1),X2) = 1 >= 1 = take(X1,X2) take(X1,active(X2)) = 1 >= 1 = take(X1,X2) problem: DPs: TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Qed DPs: length#(mark(X)) -> length#(X) length#(active(X)) -> length#(X) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [length#](x0) = x0, [take](x0, x1) = x0 + 1, [s](x0) = 0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = x0 + x1 + 1, [tt] = 0, [mark](x0) = x0 + 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0, [zeros] = 1 orientation: length#(mark(X)) = X + 1 >= X = length#(X) length#(active(X)) = X >= X = length#(X) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 2 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 0 = active(0()) mark(and(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 0 = active(tt()) mark(length(X)) = 2 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 0 = active(nil()) mark(s(X)) = 1 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = X1 + 2 >= X1 + 2 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = X1 + 2 >= X1 + 1 = take(X1,X2) take(X1,mark(X2)) = X1 + 1 >= X1 + 1 = take(X1,X2) take(active(X1),X2) = X1 + 1 >= X1 + 1 = take(X1,X2) take(X1,active(X2)) = X1 + 1 >= X1 + 1 = take(X1,X2) problem: DPs: length#(active(X)) -> length#(X) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [length#](x0) = x0 + 1, [take](x0, x1) = 0, [s](x0) = 0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = 0, [tt] = 0, [mark](x0) = 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0 + 1, [zeros] = 0 orientation: length#(active(X)) = X + 2 >= X + 1 = length#(X) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = 1 >= 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,mark(X2)) = 0 >= 0 = and(X1,X2) and(active(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,active(X2)) = 0 >= 0 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,mark(X2)) = 0 >= 0 = take(X1,X2) take(active(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,active(X2)) = 0 >= 0 = take(X1,X2) problem: DPs: TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Qed DPs: s#(mark(X)) -> s#(X) s#(active(X)) -> s#(X) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [s#](x0) = x0, [take](x0, x1) = x0 + 1, [s](x0) = 0, [length](x0) = 1, [nil] = 0, [and](x0, x1) = x0 + x1 + 1, [tt] = 0, [mark](x0) = x0 + 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0, [zeros] = 1 orientation: s#(mark(X)) = X + 1 >= X = s#(X) s#(active(X)) = X >= X = s#(X) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 2 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 0 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 0 = active(0()) mark(and(X1,X2)) = X1 + X2 + 2 >= X1 + X2 + 2 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 0 = active(tt()) mark(length(X)) = 2 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 0 = active(nil()) mark(s(X)) = 1 >= 0 = active(s(mark(X))) mark(take(X1,X2)) = X1 + 2 >= X1 + 2 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = and(X1,X2) and(active(X1),X2) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) and(X1,active(X2)) = X1 + X2 + 1 >= X1 + X2 + 1 = and(X1,X2) length(mark(X)) = 1 >= 1 = length(X) length(active(X)) = 1 >= 1 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = X1 + 2 >= X1 + 1 = take(X1,X2) take(X1,mark(X2)) = X1 + 1 >= X1 + 1 = take(X1,X2) take(active(X1),X2) = X1 + 1 >= X1 + 1 = take(X1,X2) take(X1,active(X2)) = X1 + 1 >= X1 + 1 = take(X1,X2) problem: DPs: s#(active(X)) -> s#(X) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [s#](x0) = x0 + 1, [take](x0, x1) = 0, [s](x0) = 0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = 0, [tt] = 0, [mark](x0) = 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0 + 1, [zeros] = 0 orientation: s#(active(X)) = X + 2 >= X + 1 = s#(X) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = 1 >= 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = 1 >= 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,mark(X2)) = 0 >= 0 = and(X1,X2) and(active(X1),X2) = 0 >= 0 = and(X1,X2) and(X1,active(X2)) = 0 >= 0 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,mark(X2)) = 0 >= 0 = take(X1,X2) take(active(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,active(X2)) = 0 >= 0 = take(X1,X2) problem: DPs: TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Qed DPs: take#(mark(X1),X2) -> take#(X1,X2) take#(X1,active(X2)) -> take#(X1,X2) take#(active(X1),X2) -> take#(X1,X2) take#(X1,mark(X2)) -> take#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [take#](x0, x1) = x0 + x1 + 1, [take](x0, x1) = 0, [s](x0) = 0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0 + 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0 + 1, [zeros] = 0 orientation: take#(mark(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = take#(X1,X2) take#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = take#(X1,X2) take#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = take#(X1,X2) take#(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = take#(X1,X2) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = X2 + 1 >= X2 + 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 + 1 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 + 1 >= X2 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,mark(X2)) = 0 >= 0 = take(X1,X2) take(active(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,active(X2)) = 0 >= 0 = take(X1,X2) problem: DPs: TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Qed DPs: and#(mark(X1),X2) -> and#(X1,X2) and#(X1,active(X2)) -> and#(X1,X2) and#(active(X1),X2) -> and#(X1,X2) and#(X1,mark(X2)) -> and#(X1,X2) TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Matrix Interpretation Processor: dimension: 1 interpretation: [and#](x0, x1) = x0 + x1 + 1, [take](x0, x1) = 0, [s](x0) = 0, [length](x0) = 0, [nil] = 0, [and](x0, x1) = x1, [tt] = 0, [mark](x0) = x0 + 1, [cons](x0, x1) = 0, [0] = 0, [active](x0) = x0 + 1, [zeros] = 0 orientation: and#(mark(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = and#(X1,X2) and#(X1,active(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = and#(X1,X2) and#(active(X1),X2) = X1 + X2 + 2 >= X1 + X2 + 1 = and#(X1,X2) and#(X1,mark(X2)) = X1 + X2 + 2 >= X1 + X2 + 1 = and#(X1,X2) active(zeros()) = 1 >= 1 = mark(cons(0(),zeros())) active(and(tt(),X)) = X + 1 >= X + 1 = mark(X) active(length(nil())) = 1 >= 1 = mark(0()) active(length(cons(N,L))) = 1 >= 1 = mark(s(length(L))) active(take(0(),IL)) = 1 >= 1 = mark(nil()) active(take(s(M),cons(N,IL))) = 1 >= 1 = mark(cons(N,take(M,IL))) mark(zeros()) = 1 >= 1 = active(zeros()) mark(cons(X1,X2)) = 1 >= 1 = active(cons(mark(X1),X2)) mark(0()) = 1 >= 1 = active(0()) mark(and(X1,X2)) = X2 + 1 >= X2 + 1 = active(and(mark(X1),X2)) mark(tt()) = 1 >= 1 = active(tt()) mark(length(X)) = 1 >= 1 = active(length(mark(X))) mark(nil()) = 1 >= 1 = active(nil()) mark(s(X)) = 1 >= 1 = active(s(mark(X))) mark(take(X1,X2)) = 1 >= 1 = active(take(mark(X1),mark(X2))) cons(mark(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,mark(X2)) = 0 >= 0 = cons(X1,X2) cons(active(X1),X2) = 0 >= 0 = cons(X1,X2) cons(X1,active(X2)) = 0 >= 0 = cons(X1,X2) and(mark(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,mark(X2)) = X2 + 1 >= X2 = and(X1,X2) and(active(X1),X2) = X2 >= X2 = and(X1,X2) and(X1,active(X2)) = X2 + 1 >= X2 = and(X1,X2) length(mark(X)) = 0 >= 0 = length(X) length(active(X)) = 0 >= 0 = length(X) s(mark(X)) = 0 >= 0 = s(X) s(active(X)) = 0 >= 0 = s(X) take(mark(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,mark(X2)) = 0 >= 0 = take(X1,X2) take(active(X1),X2) = 0 >= 0 = take(X1,X2) take(X1,active(X2)) = 0 >= 0 = take(X1,X2) problem: DPs: TRS: active(zeros()) -> mark(cons(0(),zeros())) active(and(tt(),X)) -> mark(X) active(length(nil())) -> mark(0()) active(length(cons(N,L))) -> mark(s(length(L))) active(take(0(),IL)) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(cons(N,take(M,IL))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(0()) -> active(0()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(length(X)) -> active(length(mark(X))) mark(nil()) -> active(nil()) mark(s(X)) -> active(s(mark(X))) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) 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) and(mark(X1),X2) -> and(X1,X2) and(X1,mark(X2)) -> and(X1,X2) and(active(X1),X2) -> and(X1,X2) and(X1,active(X2)) -> and(X1,X2) length(mark(X)) -> length(X) length(active(X)) -> length(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) take(mark(X1),X2) -> take(X1,X2) take(X1,mark(X2)) -> take(X1,X2) take(active(X1),X2) -> take(X1,X2) take(X1,active(X2)) -> take(X1,X2) Qed