YES We show the termination of the TRS R: active(and(tt(),T)) -> mark(T) active(isNatIList(IL)) -> mark(isNatList(IL)) active(isNat(|0|())) -> mark(tt()) active(isNat(s(N))) -> mark(isNat(N)) active(isNat(length(L))) -> mark(isNatList(L)) active(isNatIList(zeros())) -> mark(tt()) active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) active(isNatList(nil())) -> mark(tt()) active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) active(zeros()) -> mark(cons(|0|(),zeros())) active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) active(uTake1(tt())) -> mark(nil()) active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) active(uLength(tt(),L)) -> mark(s(length(L))) mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) mark(tt()) -> active(tt()) mark(isNatIList(X)) -> active(isNatIList(X)) mark(isNatList(X)) -> active(isNatList(X)) mark(isNat(X)) -> active(isNat(X)) mark(|0|()) -> active(|0|()) mark(s(X)) -> active(s(mark(X))) mark(length(X)) -> active(length(mark(X))) mark(zeros()) -> active(zeros()) mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) mark(nil()) -> active(nil()) mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) mark(uTake1(X)) -> active(uTake1(mark(X))) mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) mark(uLength(X1,X2)) -> active(uLength(mark(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) isNatIList(mark(X)) -> isNatIList(X) isNatIList(active(X)) -> isNatIList(X) isNatList(mark(X)) -> isNatList(X) isNatList(active(X)) -> isNatList(X) isNat(mark(X)) -> isNat(X) isNat(active(X)) -> isNat(X) s(mark(X)) -> s(X) s(active(X)) -> s(X) length(mark(X)) -> length(X) length(active(X)) -> length(X) cons(mark(X1),X2) -> cons(X1,X2) cons(X1,mark(X2)) -> cons(X1,X2) cons(active(X1),X2) -> cons(X1,X2) cons(X1,active(X2)) -> cons(X1,X2) 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) uTake1(mark(X)) -> uTake1(X) uTake1(active(X)) -> uTake1(X) uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) uLength(mark(X1),X2) -> uLength(X1,X2) uLength(X1,mark(X2)) -> uLength(X1,X2) uLength(active(X1),X2) -> uLength(X1,X2) uLength(X1,active(X2)) -> uLength(X1,X2) -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: active#(isNatIList(IL)) -> mark#(isNatList(IL)) p3: active#(isNatIList(IL)) -> isNatList#(IL) p4: active#(isNat(|0|())) -> mark#(tt()) p5: active#(isNat(s(N))) -> mark#(isNat(N)) p6: active#(isNat(s(N))) -> isNat#(N) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: active#(isNat(length(L))) -> isNatList#(L) p9: active#(isNatIList(zeros())) -> mark#(tt()) p10: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: active#(isNatIList(cons(N,IL))) -> and#(isNat(N),isNatIList(IL)) p12: active#(isNatIList(cons(N,IL))) -> isNat#(N) p13: active#(isNatIList(cons(N,IL))) -> isNatIList#(IL) p14: active#(isNatList(nil())) -> mark#(tt()) p15: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p16: active#(isNatList(cons(N,L))) -> and#(isNat(N),isNatList(L)) p17: active#(isNatList(cons(N,L))) -> isNat#(N) p18: active#(isNatList(cons(N,L))) -> isNatList#(L) p19: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p20: active#(isNatList(take(N,IL))) -> and#(isNat(N),isNatIList(IL)) p21: active#(isNatList(take(N,IL))) -> isNat#(N) p22: active#(isNatList(take(N,IL))) -> isNatIList#(IL) p23: active#(zeros()) -> mark#(cons(|0|(),zeros())) p24: active#(zeros()) -> cons#(|0|(),zeros()) p25: active#(take(|0|(),IL)) -> mark#(uTake1(isNatIList(IL))) p26: active#(take(|0|(),IL)) -> uTake1#(isNatIList(IL)) p27: active#(take(|0|(),IL)) -> isNatIList#(IL) p28: active#(uTake1(tt())) -> mark#(nil()) p29: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p30: active#(take(s(M),cons(N,IL))) -> uTake2#(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL) p31: active#(take(s(M),cons(N,IL))) -> and#(isNat(M),and(isNat(N),isNatIList(IL))) p32: active#(take(s(M),cons(N,IL))) -> isNat#(M) p33: active#(take(s(M),cons(N,IL))) -> and#(isNat(N),isNatIList(IL)) p34: active#(take(s(M),cons(N,IL))) -> isNat#(N) p35: active#(take(s(M),cons(N,IL))) -> isNatIList#(IL) p36: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p37: active#(uTake2(tt(),M,N,IL)) -> cons#(N,take(M,IL)) p38: active#(uTake2(tt(),M,N,IL)) -> take#(M,IL) p39: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p40: active#(length(cons(N,L))) -> uLength#(and(isNat(N),isNatList(L)),L) p41: active#(length(cons(N,L))) -> and#(isNat(N),isNatList(L)) p42: active#(length(cons(N,L))) -> isNat#(N) p43: active#(length(cons(N,L))) -> isNatList#(L) p44: active#(uLength(tt(),L)) -> mark#(s(length(L))) p45: active#(uLength(tt(),L)) -> s#(length(L)) p46: active#(uLength(tt(),L)) -> length#(L) p47: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p48: mark#(and(X1,X2)) -> and#(mark(X1),mark(X2)) p49: mark#(and(X1,X2)) -> mark#(X1) p50: mark#(and(X1,X2)) -> mark#(X2) p51: mark#(tt()) -> active#(tt()) p52: mark#(isNatIList(X)) -> active#(isNatIList(X)) p53: mark#(isNatList(X)) -> active#(isNatList(X)) p54: mark#(isNat(X)) -> active#(isNat(X)) p55: mark#(|0|()) -> active#(|0|()) p56: mark#(s(X)) -> active#(s(mark(X))) p57: mark#(s(X)) -> s#(mark(X)) p58: mark#(s(X)) -> mark#(X) p59: mark#(length(X)) -> active#(length(mark(X))) p60: mark#(length(X)) -> length#(mark(X)) p61: mark#(length(X)) -> mark#(X) p62: mark#(zeros()) -> active#(zeros()) p63: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p64: mark#(cons(X1,X2)) -> cons#(mark(X1),X2) p65: mark#(cons(X1,X2)) -> mark#(X1) p66: mark#(nil()) -> active#(nil()) p67: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p68: mark#(take(X1,X2)) -> take#(mark(X1),mark(X2)) p69: mark#(take(X1,X2)) -> mark#(X1) p70: mark#(take(X1,X2)) -> mark#(X2) p71: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p72: mark#(uTake1(X)) -> uTake1#(mark(X)) p73: mark#(uTake1(X)) -> mark#(X) p74: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p75: mark#(uTake2(X1,X2,X3,X4)) -> uTake2#(mark(X1),X2,X3,X4) p76: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p77: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p78: mark#(uLength(X1,X2)) -> uLength#(mark(X1),X2) p79: mark#(uLength(X1,X2)) -> mark#(X1) p80: and#(mark(X1),X2) -> and#(X1,X2) p81: and#(X1,mark(X2)) -> and#(X1,X2) p82: and#(active(X1),X2) -> and#(X1,X2) p83: and#(X1,active(X2)) -> and#(X1,X2) p84: isNatIList#(mark(X)) -> isNatIList#(X) p85: isNatIList#(active(X)) -> isNatIList#(X) p86: isNatList#(mark(X)) -> isNatList#(X) p87: isNatList#(active(X)) -> isNatList#(X) p88: isNat#(mark(X)) -> isNat#(X) p89: isNat#(active(X)) -> isNat#(X) p90: s#(mark(X)) -> s#(X) p91: s#(active(X)) -> s#(X) p92: length#(mark(X)) -> length#(X) p93: length#(active(X)) -> length#(X) p94: cons#(mark(X1),X2) -> cons#(X1,X2) p95: cons#(X1,mark(X2)) -> cons#(X1,X2) p96: cons#(active(X1),X2) -> cons#(X1,X2) p97: cons#(X1,active(X2)) -> cons#(X1,X2) p98: take#(mark(X1),X2) -> take#(X1,X2) p99: take#(X1,mark(X2)) -> take#(X1,X2) p100: take#(active(X1),X2) -> take#(X1,X2) p101: take#(X1,active(X2)) -> take#(X1,X2) p102: uTake1#(mark(X)) -> uTake1#(X) p103: uTake1#(active(X)) -> uTake1#(X) p104: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p105: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) p106: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p107: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4) p108: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p109: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) p110: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p111: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) p112: uLength#(mark(X1),X2) -> uLength#(X1,X2) p113: uLength#(X1,mark(X2)) -> uLength#(X1,X2) p114: uLength#(active(X1),X2) -> uLength#(X1,X2) p115: uLength#(X1,active(X2)) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p5, p7, p10, p15, p19, p23, p25, p29, p36, p39, p44, p47, p49, p50, p52, p53, p54, p56, p58, p59, p61, p62, p63, p65, p67, p69, p70, p71, p73, p74, p76, p77, p79} {p86, p87} {p88, p89} {p80, p81, p82, p83} {p84, p85} {p102, p103} {p104, p105, p106, p107, p108, p109, p110, p111} {p94, p95, p96, p97} {p98, p99, p100, p101} {p112, p113, p114, p115} {p90, p91} {p92, p93} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> mark#(X1) p3: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) p5: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p6: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p7: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p8: mark#(uTake1(X)) -> mark#(X) p9: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p10: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p11: mark#(take(X1,X2)) -> mark#(X2) p12: mark#(take(X1,X2)) -> mark#(X1) p13: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p14: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p15: mark#(cons(X1,X2)) -> mark#(X1) p16: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p17: active#(take(|0|(),IL)) -> mark#(uTake1(isNatIList(IL))) p18: mark#(zeros()) -> active#(zeros()) p19: active#(zeros()) -> mark#(cons(|0|(),zeros())) p20: mark#(length(X)) -> mark#(X) p21: mark#(length(X)) -> active#(length(mark(X))) p22: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p23: mark#(s(X)) -> mark#(X) p24: mark#(s(X)) -> active#(s(mark(X))) p25: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p26: mark#(isNat(X)) -> active#(isNat(X)) p27: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p28: mark#(isNatList(X)) -> active#(isNatList(X)) p29: active#(isNat(length(L))) -> mark#(isNatList(L)) p30: mark#(isNatIList(X)) -> active#(isNatIList(X)) p31: active#(isNat(s(N))) -> mark#(isNat(N)) p32: mark#(and(X1,X2)) -> mark#(X2) p33: mark#(and(X1,X2)) -> mark#(X1) p34: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p35: active#(isNatIList(IL)) -> mark#(isNatList(IL)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{18, x1 + 16} and_A(x1,x2) = max{4, x1, x2} tt_A = 9 mark#_A(x1) = max{17, x1 + 16} uLength_A(x1,x2) = max{x1 + 34, x2 + 39} mark_A(x1) = x1 s_A(x1) = max{22, x1} length_A(x1) = max{43, x1 + 39} uTake2_A(x1,x2,x3,x4) = max{x1 + 4, x2 + 65, x3 + 47, x4 + 47} cons_A(x1,x2) = max{3, x1, x2} isNat_A(x1) = 9 isNatList_A(x1) = 9 uTake1_A(x1) = x1 + 20 take_A(x1,x2) = max{x1 + 65, x2 + 47} isNatIList_A(x1) = 9 |0|_A = 13 zeros_A = 13 active_A(x1) = x1 nil_A = 16 precedence: mark = uTake2 = isNat = isNatList = take = |0| = active > active# = tt = mark# = uLength = isNatIList > and = cons = zeros > nil > s = length = uTake1 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [1] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(uTake1) = [] pi(take) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p17 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> mark#(X1) p3: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) p5: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p6: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p7: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p8: mark#(uTake1(X)) -> mark#(X) p9: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p10: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p11: mark#(take(X1,X2)) -> mark#(X2) p12: mark#(take(X1,X2)) -> mark#(X1) p13: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p14: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p15: mark#(cons(X1,X2)) -> mark#(X1) p16: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p17: mark#(zeros()) -> active#(zeros()) p18: active#(zeros()) -> mark#(cons(|0|(),zeros())) p19: mark#(length(X)) -> mark#(X) p20: mark#(length(X)) -> active#(length(mark(X))) p21: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p22: mark#(s(X)) -> mark#(X) p23: mark#(s(X)) -> active#(s(mark(X))) p24: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p25: mark#(isNat(X)) -> active#(isNat(X)) p26: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p27: mark#(isNatList(X)) -> active#(isNatList(X)) p28: active#(isNat(length(L))) -> mark#(isNatList(L)) p29: mark#(isNatIList(X)) -> active#(isNatIList(X)) p30: active#(isNat(s(N))) -> mark#(isNat(N)) p31: mark#(and(X1,X2)) -> mark#(X2) p32: mark#(and(X1,X2)) -> mark#(X1) p33: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p34: active#(isNatIList(IL)) -> mark#(isNatList(IL)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNatIList(IL)) -> mark#(isNatList(IL)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(s(N))) -> mark#(isNat(N)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNat(length(L))) -> mark#(isNatList(L)) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p17: mark#(length(X)) -> mark#(X) p18: mark#(zeros()) -> active#(zeros()) p19: active#(zeros()) -> mark#(cons(|0|(),zeros())) p20: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p21: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p22: mark#(cons(X1,X2)) -> mark#(X1) p23: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p24: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p25: mark#(take(X1,X2)) -> mark#(X1) p26: mark#(take(X1,X2)) -> mark#(X2) p27: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p28: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p29: mark#(uTake1(X)) -> mark#(X) p30: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p31: active#(uLength(tt(),L)) -> mark#(s(length(L))) p32: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p33: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p34: mark#(uLength(X1,X2)) -> mark#(X1) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{22, x1 - 6} and_A(x1,x2) = max{45, x1, x2} tt_A = 69 mark#_A(x1) = max{14, x1 - 6} mark_A(x1) = x1 isNatIList_A(x1) = x1 + 52 isNatList_A(x1) = x1 + 47 isNat_A(x1) = max{43, x1 - 21} s_A(x1) = max{69, x1} length_A(x1) = x1 + 68 cons_A(x1,x2) = max{x1 + 44, x2} take_A(x1,x2) = max{x1 + 7, x2 + 88} zeros_A = 136 |0|_A = 91 uTake2_A(x1,x2,x3,x4) = max{x1, x2 + 7, x3 + 132, x4 + 88} uTake1_A(x1) = x1 + 36 uLength_A(x1,x2) = max{x1, x2 + 68} active_A(x1) = max{21, x1} nil_A = 22 precedence: and = isNatList = isNat = length = take = uLength > zeros > tt > active# = mark# = mark = isNatIList = s = cons = |0| = uTake2 = uTake1 = active = nil partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNatIList) = [] pi(isNatList) = [] pi(isNat) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uTake2) = [] pi(uTake1) = [] pi(uLength) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(isNatIList(X)) -> active#(isNatIList(X)) p6: active#(isNat(s(N))) -> mark#(isNat(N)) p7: mark#(isNatList(X)) -> active#(isNatList(X)) p8: active#(isNat(length(L))) -> mark#(isNatList(L)) p9: mark#(isNat(X)) -> active#(isNat(X)) p10: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: mark#(s(X)) -> active#(s(mark(X))) p12: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p13: mark#(s(X)) -> mark#(X) p14: mark#(length(X)) -> active#(length(mark(X))) p15: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p16: mark#(length(X)) -> mark#(X) p17: mark#(zeros()) -> active#(zeros()) p18: active#(zeros()) -> mark#(cons(|0|(),zeros())) p19: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p20: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p21: mark#(cons(X1,X2)) -> mark#(X1) p22: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p23: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p24: mark#(take(X1,X2)) -> mark#(X1) p25: mark#(take(X1,X2)) -> mark#(X2) p26: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p27: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p28: mark#(uTake1(X)) -> mark#(X) p29: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p30: active#(uLength(tt(),L)) -> mark#(s(length(L))) p31: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p32: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p33: mark#(uLength(X1,X2)) -> mark#(X1) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> mark#(X1) p3: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) p5: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p6: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p7: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p8: mark#(uTake1(X)) -> mark#(X) p9: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p10: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p11: mark#(take(X1,X2)) -> mark#(X2) p12: mark#(take(X1,X2)) -> mark#(X1) p13: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p14: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p15: mark#(cons(X1,X2)) -> mark#(X1) p16: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p17: active#(zeros()) -> mark#(cons(|0|(),zeros())) p18: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p19: mark#(zeros()) -> active#(zeros()) p20: mark#(length(X)) -> mark#(X) p21: mark#(length(X)) -> active#(length(mark(X))) p22: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p23: mark#(s(X)) -> mark#(X) p24: mark#(s(X)) -> active#(s(mark(X))) p25: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p26: mark#(isNat(X)) -> active#(isNat(X)) p27: active#(isNat(length(L))) -> mark#(isNatList(L)) p28: mark#(isNatList(X)) -> active#(isNatList(X)) p29: active#(isNat(s(N))) -> mark#(isNat(N)) p30: mark#(isNatIList(X)) -> active#(isNatIList(X)) p31: mark#(and(X1,X2)) -> mark#(X2) p32: mark#(and(X1,X2)) -> mark#(X1) p33: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{11, x1} and_A(x1,x2) = max{62, x1 + 8, x2} tt_A = 33 mark#_A(x1) = max{11, x1} uLength_A(x1,x2) = max{34, x1 + 3, x2 + 8} mark_A(x1) = max{9, x1} s_A(x1) = max{9, x1} length_A(x1) = max{35, x1 + 8} uTake2_A(x1,x2,x3,x4) = max{99, x1, x2 + 48, x3 + 56, x4 + 38} cons_A(x1,x2) = max{61, x1 + 25, x2} isNat_A(x1) = max{4, x1 - 3} isNatList_A(x1) = max{11, x1 + 5} uTake1_A(x1) = max{9, x1} take_A(x1,x2) = max{57, x1 + 48, x2 + 38} isNatIList_A(x1) = x1 + 11 zeros_A = 61 |0|_A = 36 active_A(x1) = max{9, x1} nil_A = 33 precedence: length = uTake1 = |0| > uLength = s > zeros > cons = isNatList > and = isNatIList > tt > active# = mark# = uTake2 = isNat = take = nil > mark = active partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(uTake1) = [] pi(take) = [] pi(isNatIList) = [] pi(zeros) = [] pi(|0|) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p12 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> mark#(X1) p3: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) p5: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p6: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p7: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p8: mark#(uTake1(X)) -> mark#(X) p9: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p10: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p11: mark#(take(X1,X2)) -> mark#(X2) p12: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p13: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p14: mark#(cons(X1,X2)) -> mark#(X1) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(length(X)) -> mark#(X) p20: mark#(length(X)) -> active#(length(mark(X))) p21: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p22: mark#(s(X)) -> mark#(X) p23: mark#(s(X)) -> active#(s(mark(X))) p24: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p25: mark#(isNat(X)) -> active#(isNat(X)) p26: active#(isNat(length(L))) -> mark#(isNatList(L)) p27: mark#(isNatList(X)) -> active#(isNatList(X)) p28: active#(isNat(s(N))) -> mark#(isNat(N)) p29: mark#(isNatIList(X)) -> active#(isNatIList(X)) p30: mark#(and(X1,X2)) -> mark#(X2) p31: mark#(and(X1,X2)) -> mark#(X1) p32: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p19: mark#(length(X)) -> mark#(X) p20: mark#(zeros()) -> active#(zeros()) p21: mark#(cons(X1,X2)) -> mark#(X1) p22: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p23: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p24: mark#(take(X1,X2)) -> mark#(X2) p25: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p26: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p27: mark#(uTake1(X)) -> mark#(X) p28: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p29: active#(uLength(tt(),L)) -> mark#(s(length(L))) p30: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p31: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p32: mark#(uLength(X1,X2)) -> mark#(X1) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{38, x1 + 24} and_A(x1,x2) = max{3, x1, x2} tt_A = 14 mark#_A(x1) = max{38, x1 + 24} mark_A(x1) = max{4, x1} isNat_A(x1) = max{1, x1 - 15} s_A(x1) = max{41, x1} isNatIList_A(x1) = max{4, x1} length_A(x1) = max{29, x1 + 25} isNatList_A(x1) = x1 cons_A(x1,x2) = max{23, x1 + 15, x2} take_A(x1,x2) = max{9, x1 + 5, x2} zeros_A = 46 |0|_A = 30 uTake2_A(x1,x2,x3,x4) = max{23, x1, x2 + 5, x3 + 15, x4} uTake1_A(x1) = x1 uLength_A(x1,x2) = max{41, x1 + 25, x2 + 25} active_A(x1) = max{2, x1} nil_A = 14 precedence: tt > isNatIList = length = isNatList = take = |0| = nil > isNat = zeros > active# = mark# > uLength > and = mark = s = cons = uTake2 = uTake1 = active partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(length) = [] pi(isNatList) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uTake2) = [] pi(uTake1) = [] pi(uLength) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p32 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p19: mark#(length(X)) -> mark#(X) p20: mark#(zeros()) -> active#(zeros()) p21: mark#(cons(X1,X2)) -> mark#(X1) p22: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p23: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p24: mark#(take(X1,X2)) -> mark#(X2) p25: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p26: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p27: mark#(uTake1(X)) -> mark#(X) p28: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p29: active#(uLength(tt(),L)) -> mark#(s(length(L))) p30: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p31: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> mark#(X) p8: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p9: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL))) p10: mark#(take(X1,X2)) -> mark#(X2) p11: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p12: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p13: mark#(cons(X1,X2)) -> mark#(X1) p14: mark#(zeros()) -> active#(zeros()) p15: active#(zeros()) -> mark#(cons(|0|(),zeros())) p16: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p17: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p18: mark#(length(X)) -> mark#(X) p19: mark#(length(X)) -> active#(length(mark(X))) p20: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p21: mark#(s(X)) -> mark#(X) p22: mark#(s(X)) -> active#(s(mark(X))) p23: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p24: mark#(isNat(X)) -> active#(isNat(X)) p25: active#(isNat(length(L))) -> mark#(isNatList(L)) p26: mark#(isNatList(X)) -> active#(isNatList(X)) p27: active#(isNat(s(N))) -> mark#(isNat(N)) p28: mark#(isNatIList(X)) -> active#(isNatIList(X)) p29: mark#(and(X1,X2)) -> mark#(X2) p30: mark#(and(X1,X2)) -> mark#(X1) p31: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = x1 + 37 and_A(x1,x2) = max{18, x1, x2} tt_A = 21 mark#_A(x1) = x1 + 37 uLength_A(x1,x2) = max{19, x1 - 4, x2} mark_A(x1) = x1 s_A(x1) = max{18, x1} length_A(x1) = max{16, x1} uTake2_A(x1,x2,x3,x4) = max{x1, x3 + 37, x4 + 37} cons_A(x1,x2) = max{x1 + 37, x2} isNat_A(x1) = 21 isNatList_A(x1) = 21 uTake1_A(x1) = max{37, x1 + 15} take_A(x1,x2) = x2 + 37 isNatIList_A(x1) = 21 zeros_A = 61 |0|_A = 23 active_A(x1) = max{16, x1} nil_A = 22 precedence: and = uLength = s = length = uTake2 = isNat = isNatList = take = isNatIList = |0| = nil > tt = zeros > cons > active# = mark# = mark = uTake1 = active partial status: pi(active#) = [1] pi(and) = [] pi(tt) = [] pi(mark#) = [1] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(uTake1) = [] pi(take) = [] pi(isNatIList) = [] pi(zeros) = [] pi(|0|) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p9 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> mark#(X) p8: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p9: mark#(take(X1,X2)) -> mark#(X2) p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p11: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p12: mark#(cons(X1,X2)) -> mark#(X1) p13: mark#(zeros()) -> active#(zeros()) p14: active#(zeros()) -> mark#(cons(|0|(),zeros())) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p17: mark#(length(X)) -> mark#(X) p18: mark#(length(X)) -> active#(length(mark(X))) p19: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p20: mark#(s(X)) -> mark#(X) p21: mark#(s(X)) -> active#(s(mark(X))) p22: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p23: mark#(isNat(X)) -> active#(isNat(X)) p24: active#(isNat(length(L))) -> mark#(isNatList(L)) p25: mark#(isNatList(X)) -> active#(isNatList(X)) p26: active#(isNat(s(N))) -> mark#(isNat(N)) p27: mark#(isNatIList(X)) -> active#(isNatIList(X)) p28: mark#(and(X1,X2)) -> mark#(X2) p29: mark#(and(X1,X2)) -> mark#(X1) p30: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p19: mark#(length(X)) -> mark#(X) p20: mark#(zeros()) -> active#(zeros()) p21: mark#(cons(X1,X2)) -> mark#(X1) p22: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p23: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p24: mark#(take(X1,X2)) -> mark#(X2) p25: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p26: active#(uLength(tt(),L)) -> mark#(s(length(L))) p27: mark#(uTake1(X)) -> mark#(X) p28: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p29: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p30: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = x1 + 47 and_A(x1,x2) = max{2, x1, x2} tt_A = 22 mark#_A(x1) = x1 + 47 mark_A(x1) = x1 isNat_A(x1) = 30 s_A(x1) = max{21, x1} isNatIList_A(x1) = 30 length_A(x1) = x1 + 26 isNatList_A(x1) = 30 cons_A(x1,x2) = max{x1 + 4, x2} take_A(x1,x2) = max{x1 + 45, x2 + 30} zeros_A = 21 |0|_A = 17 uTake2_A(x1,x2,x3,x4) = max{x1 + 6, x2 + 45, x3 + 5, x4 + 30} uLength_A(x1,x2) = max{x1, x2 + 26} uTake1_A(x1) = x1 + 31 active_A(x1) = max{2, x1} nil_A = 52 precedence: zeros = uLength > isNat = take > isNatList > s > |0| > nil > tt > cons > active# = and = mark# = mark = isNatIList = length = uTake2 = uTake1 = active partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(length) = [] pi(isNatList) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uTake2) = [] pi(uLength) = [] pi(uTake1) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p27 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p19: mark#(length(X)) -> mark#(X) p20: mark#(zeros()) -> active#(zeros()) p21: mark#(cons(X1,X2)) -> mark#(X1) p22: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p23: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p24: mark#(take(X1,X2)) -> mark#(X2) p25: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p26: active#(uLength(tt(),L)) -> mark#(s(length(L))) p27: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p28: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p29: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p9: mark#(take(X1,X2)) -> mark#(X2) p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p11: active#(zeros()) -> mark#(cons(|0|(),zeros())) p12: mark#(cons(X1,X2)) -> mark#(X1) p13: mark#(zeros()) -> active#(zeros()) p14: mark#(length(X)) -> mark#(X) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p17: mark#(length(X)) -> active#(length(mark(X))) p18: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p19: mark#(s(X)) -> mark#(X) p20: mark#(s(X)) -> active#(s(mark(X))) p21: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p22: mark#(isNat(X)) -> active#(isNat(X)) p23: active#(isNat(length(L))) -> mark#(isNatList(L)) p24: mark#(isNatList(X)) -> active#(isNatList(X)) p25: active#(isNat(s(N))) -> mark#(isNat(N)) p26: mark#(isNatIList(X)) -> active#(isNatIList(X)) p27: mark#(and(X1,X2)) -> mark#(X2) p28: mark#(and(X1,X2)) -> mark#(X1) p29: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{5, x1 - 18} and_A(x1,x2) = max{7, x1, x2} tt_A = 20 mark#_A(x1) = max{5, x1 - 18} uLength_A(x1,x2) = max{73, x1 + 42, x2 + 56} mark_A(x1) = max{23, x1} s_A(x1) = max{24, x1} length_A(x1) = max{73, x1 + 50} uTake2_A(x1,x2,x3,x4) = max{x1, x3, x4 + 14} cons_A(x1,x2) = max{x1, x2 + 14} isNat_A(x1) = 0 isNatList_A(x1) = 23 uTake1_A(x1) = max{23, x1 - 12} take_A(x1,x2) = max{8, x2} isNatIList_A(x1) = 19 zeros_A = 8 |0|_A = 8 active_A(x1) = max{23, x1} nil_A = 0 precedence: active# = mark# = uLength = mark = s = length = isNat = uTake1 = zeros = active > |0| > cons = isNatList > and = tt = uTake2 = isNatIList = nil > take partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [4] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(uTake1) = [] pi(take) = [] pi(isNatIList) = [] pi(zeros) = [] pi(|0|) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p14 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p9: mark#(take(X1,X2)) -> mark#(X2) p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p11: active#(zeros()) -> mark#(cons(|0|(),zeros())) p12: mark#(cons(X1,X2)) -> mark#(X1) p13: mark#(zeros()) -> active#(zeros()) p14: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p15: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p16: mark#(length(X)) -> active#(length(mark(X))) p17: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p18: mark#(s(X)) -> mark#(X) p19: mark#(s(X)) -> active#(s(mark(X))) p20: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p21: mark#(isNat(X)) -> active#(isNat(X)) p22: active#(isNat(length(L))) -> mark#(isNatList(L)) p23: mark#(isNatList(X)) -> active#(isNatList(X)) p24: active#(isNat(s(N))) -> mark#(isNat(N)) p25: mark#(isNatIList(X)) -> active#(isNatIList(X)) p26: mark#(and(X1,X2)) -> mark#(X2) p27: mark#(and(X1,X2)) -> mark#(X1) p28: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> active#(s(mark(X))) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(s(X)) -> mark#(X) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p19: mark#(zeros()) -> active#(zeros()) p20: mark#(cons(X1,X2)) -> mark#(X1) p21: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p22: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p23: mark#(take(X1,X2)) -> mark#(X2) p24: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p25: active#(uLength(tt(),L)) -> mark#(s(length(L))) p26: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p27: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p28: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{461, x1} and_A(x1,x2) = 462 tt_A = 462 mark#_A(x1) = 462 mark_A(x1) = 618 isNat_A(x1) = 462 s_A(x1) = 157 isNatIList_A(x1) = 462 length_A(x1) = 462 isNatList_A(x1) = 462 cons_A(x1,x2) = 434 take_A(x1,x2) = 462 zeros_A = 462 |0|_A = 462 uTake2_A(x1,x2,x3,x4) = 462 uLength_A(x1,x2) = 462 uTake1_A(x1) = 462 active_A(x1) = max{460, x1 + 156} nil_A = 462 precedence: and > isNatList > active# = mark# = take > isNat = isNatIList > tt = mark = s = length = cons = zeros = |0| = uTake2 = uLength = uTake1 = active = nil partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(length) = [] pi(isNatList) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uTake2) = [] pi(uLength) = [] pi(uTake1) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p12 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p13: mark#(s(X)) -> mark#(X) p14: mark#(length(X)) -> active#(length(mark(X))) p15: active#(zeros()) -> mark#(cons(|0|(),zeros())) p16: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p17: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(cons(X1,X2)) -> mark#(X1) p20: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p21: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p22: mark#(take(X1,X2)) -> mark#(X2) p23: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p24: active#(uLength(tt(),L)) -> mark#(s(length(L))) p25: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p26: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p27: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p9: mark#(take(X1,X2)) -> mark#(X2) p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p11: active#(zeros()) -> mark#(cons(|0|(),zeros())) p12: mark#(cons(X1,X2)) -> mark#(X1) p13: mark#(zeros()) -> active#(zeros()) p14: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p15: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p16: mark#(length(X)) -> active#(length(mark(X))) p17: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p18: mark#(s(X)) -> mark#(X) p19: mark#(isNat(X)) -> active#(isNat(X)) p20: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p21: mark#(isNatList(X)) -> active#(isNatList(X)) p22: active#(isNat(length(L))) -> mark#(isNatList(L)) p23: mark#(isNatIList(X)) -> active#(isNatIList(X)) p24: active#(isNat(s(N))) -> mark#(isNat(N)) p25: mark#(and(X1,X2)) -> mark#(X2) p26: mark#(and(X1,X2)) -> mark#(X1) p27: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = x1 + 15 and_A(x1,x2) = max{1, x1, x2} tt_A = 24 mark#_A(x1) = max{39, x1 + 15} uLength_A(x1,x2) = max{x1 + 34, x2 + 56} mark_A(x1) = x1 s_A(x1) = x1 length_A(x1) = x1 + 56 uTake2_A(x1,x2,x3,x4) = max{x1 + 3, x2 + 69, x3 + 74, x4 + 40} cons_A(x1,x2) = max{x1 + 34, x2} isNat_A(x1) = 24 isNatList_A(x1) = 24 uTake1_A(x1) = max{73, x1 + 49} take_A(x1,x2) = max{73, x1 + 69, x2 + 40} isNatIList_A(x1) = 24 zeros_A = 38 |0|_A = 3 active_A(x1) = x1 nil_A = 1 precedence: uTake2 = zeros = |0| = nil > active# = and = tt = mark# = uLength = mark = s = length = cons = isNat = isNatList = uTake1 = take = isNatIList = active partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(uTake1) = [] pi(take) = [] pi(isNatIList) = [] pi(zeros) = [] pi(|0|) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p12 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p9: mark#(take(X1,X2)) -> mark#(X2) p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p11: active#(zeros()) -> mark#(cons(|0|(),zeros())) p12: mark#(zeros()) -> active#(zeros()) p13: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p14: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p15: mark#(length(X)) -> active#(length(mark(X))) p16: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p17: mark#(s(X)) -> mark#(X) p18: mark#(isNat(X)) -> active#(isNat(X)) p19: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p20: mark#(isNatList(X)) -> active#(isNatList(X)) p21: active#(isNat(length(L))) -> mark#(isNatList(L)) p22: mark#(isNatIList(X)) -> active#(isNatIList(X)) p23: active#(isNat(s(N))) -> mark#(isNat(N)) p24: mark#(and(X1,X2)) -> mark#(X2) p25: mark#(and(X1,X2)) -> mark#(X1) p26: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p20: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p21: mark#(take(X1,X2)) -> mark#(X2) p22: mark#(uTake1(X)) -> active#(uTake1(mark(X))) p23: active#(uLength(tt(),L)) -> mark#(s(length(L))) p24: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p25: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p26: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{112, x1 - 13} and_A(x1,x2) = 127 tt_A = 61 mark#_A(x1) = 114 mark_A(x1) = 87 isNat_A(x1) = 127 s_A(x1) = 46 isNatIList_A(x1) = 127 length_A(x1) = 127 isNatList_A(x1) = 127 cons_A(x1,x2) = 127 take_A(x1,x2) = 127 zeros_A = 127 |0|_A = 17 uTake2_A(x1,x2,x3,x4) = 127 uLength_A(x1,x2) = 127 uTake1_A(x1) = 122 active_A(x1) = max{87, x1 - 40} nil_A = 21 precedence: isNatIList > length = isNatList > mark = isNat = s = zeros = active = nil > and = |0| > uTake1 > active# = tt = mark# = take = uTake2 = uLength > cons partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(length) = [] pi(isNatList) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uTake2) = [] pi(uLength) = [] pi(uTake1) = [] pi(active) = [] pi(nil) = [] The next rules are strictly ordered: p22 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p20: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p21: mark#(take(X1,X2)) -> mark#(X2) p22: active#(uLength(tt(),L)) -> mark#(s(length(L))) p23: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p24: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p25: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(take(X1,X2)) -> mark#(X2) p8: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p9: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) p10: mark#(zeros()) -> active#(zeros()) p11: active#(zeros()) -> mark#(cons(|0|(),zeros())) p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p13: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p14: mark#(length(X)) -> active#(length(mark(X))) p15: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p16: mark#(s(X)) -> mark#(X) p17: mark#(isNat(X)) -> active#(isNat(X)) p18: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p19: mark#(isNatList(X)) -> active#(isNatList(X)) p20: active#(isNat(length(L))) -> mark#(isNatList(L)) p21: mark#(isNatIList(X)) -> active#(isNatIList(X)) p22: active#(isNat(s(N))) -> mark#(isNat(N)) p23: mark#(and(X1,X2)) -> mark#(X2) p24: mark#(and(X1,X2)) -> mark#(X1) p25: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{57, x1 - 11} and_A(x1,x2) = max{65, x1, x2} tt_A = 9 mark#_A(x1) = max{57, x1 - 11} uLength_A(x1,x2) = 43 mark_A(x1) = max{67, x1} s_A(x1) = max{44, x1} length_A(x1) = 20 uTake2_A(x1,x2,x3,x4) = max{147, x1 + 79, x2 + 97} cons_A(x1,x2) = 76 isNat_A(x1) = 73 isNatList_A(x1) = 73 take_A(x1,x2) = max{241, x1 + 107, x2 + 173} isNatIList_A(x1) = 73 zeros_A = 80 |0|_A = 58 active_A(x1) = max{67, x1} nil_A = 0 uTake1_A(x1) = max{241, x1 + 100} precedence: |0| > uLength = length > s > uTake1 > uTake2 = take = zeros > active# = tt = mark# = mark = isNat = isNatList = active > cons = nil > and = isNatIList partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(take) = [] pi(isNatIList) = [] pi(zeros) = [] pi(|0|) = [] pi(active) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p9 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(take(X1,X2)) -> mark#(X2) p8: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p9: mark#(zeros()) -> active#(zeros()) p10: active#(zeros()) -> mark#(cons(|0|(),zeros())) p11: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p12: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p15: mark#(s(X)) -> mark#(X) p16: mark#(isNat(X)) -> active#(isNat(X)) p17: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p18: mark#(isNatList(X)) -> active#(isNatList(X)) p19: active#(isNat(length(L))) -> mark#(isNatList(L)) p20: mark#(isNatIList(X)) -> active#(isNatIList(X)) p21: active#(isNat(s(N))) -> mark#(isNat(N)) p22: mark#(and(X1,X2)) -> mark#(X2) p23: mark#(and(X1,X2)) -> mark#(X1) p24: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p20: active#(uLength(tt(),L)) -> mark#(s(length(L))) p21: mark#(take(X1,X2)) -> mark#(X2) p22: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p23: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p24: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{25, x1 - 21} and_A(x1,x2) = max{64, x1, x2} tt_A = 48 mark#_A(x1) = max{23, x1 - 21} mark_A(x1) = max{50, x1} isNat_A(x1) = 64 s_A(x1) = max{54, x1} isNatIList_A(x1) = 64 length_A(x1) = 70 isNatList_A(x1) = 64 cons_A(x1,x2) = 47 take_A(x1,x2) = max{239, x1 + 137, x2 + 167} zeros_A = 50 |0|_A = 0 uLength_A(x1,x2) = 70 uTake2_A(x1,x2,x3,x4) = max{136, x1 + 72, x2 + 131} active_A(x1) = max{6, x1} nil_A = 138 uTake1_A(x1) = 138 precedence: zeros > uTake2 > uTake1 > isNatIList = isNatList > nil > and > take > mark = isNat = uLength = active > cons = |0| > active# = tt = mark# = s = length partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(length) = [] pi(isNatList) = [] pi(cons) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(uLength) = [] pi(uTake2) = [] pi(active) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p21 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNat(length(L))) -> mark#(isNatList(L)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(zeros()) -> mark#(cons(|0|(),zeros())) p17: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p18: mark#(zeros()) -> active#(zeros()) p19: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p20: active#(uLength(tt(),L)) -> mark#(s(length(L))) p21: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p22: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p23: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p8: active#(zeros()) -> mark#(cons(|0|(),zeros())) p9: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p10: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: mark#(zeros()) -> active#(zeros()) p12: mark#(length(X)) -> active#(length(mark(X))) p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p14: mark#(s(X)) -> mark#(X) p15: mark#(isNat(X)) -> active#(isNat(X)) p16: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p17: mark#(isNatList(X)) -> active#(isNatList(X)) p18: active#(isNat(length(L))) -> mark#(isNatList(L)) p19: mark#(isNatIList(X)) -> active#(isNatIList(X)) p20: active#(isNat(s(N))) -> mark#(isNat(N)) p21: mark#(and(X1,X2)) -> mark#(X2) p22: mark#(and(X1,X2)) -> mark#(X1) p23: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{1, x1 - 3} and_A(x1,x2) = max{x1 + 6, x2} tt_A = 28 mark#_A(x1) = max{0, x1 - 3} uLength_A(x1,x2) = max{x1 + 19, x2 + 49} mark_A(x1) = x1 s_A(x1) = max{49, x1} length_A(x1) = x1 + 49 uTake2_A(x1,x2,x3,x4) = max{x1 + 26, x2 + 54, x3 + 22, x4 + 105} cons_A(x1,x2) = max{23, x1 + 22, x2} isNat_A(x1) = x1 + 15 isNatList_A(x1) = x1 + 24 take_A(x1,x2) = max{x1 + 54, x2 + 105} zeros_A = 35 |0|_A = 13 isNatIList_A(x1) = x1 + 79 active_A(x1) = max{6, x1} nil_A = 53 uTake1_A(x1) = x1 + 26 precedence: active# = and = tt = mark# = uLength = mark = s = length = uTake2 = cons = isNat = isNatList = take = zeros = |0| = isNatIList = active = nil = uTake1 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(take) = [] pi(zeros) = [] pi(|0|) = [] pi(isNatIList) = [] pi(active) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p18 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p8: active#(zeros()) -> mark#(cons(|0|(),zeros())) p9: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p10: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: mark#(zeros()) -> active#(zeros()) p12: mark#(length(X)) -> active#(length(mark(X))) p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p14: mark#(s(X)) -> mark#(X) p15: mark#(isNat(X)) -> active#(isNat(X)) p16: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p17: mark#(isNatList(X)) -> active#(isNatList(X)) p18: mark#(isNatIList(X)) -> active#(isNatIList(X)) p19: active#(isNat(s(N))) -> mark#(isNat(N)) p20: mark#(and(X1,X2)) -> mark#(X2) p21: mark#(and(X1,X2)) -> mark#(X1) p22: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(zeros()) -> mark#(cons(|0|(),zeros())) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p17: mark#(zeros()) -> active#(zeros()) p18: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p19: active#(uLength(tt(),L)) -> mark#(s(length(L))) p20: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p21: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p22: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{107, x1 - 61} and_A(x1,x2) = max{146, x1, x2} tt_A = 149 mark#_A(x1) = max{107, x1 - 61} mark_A(x1) = max{151, x1} isNat_A(x1) = 148 s_A(x1) = max{151, x1} isNatIList_A(x1) = 43 cons_A(x1,x2) = max{3, x2 - 33} isNatList_A(x1) = 108 take_A(x1,x2) = max{813, x1 + 427, x2 + 662} length_A(x1) = 104 zeros_A = 202 |0|_A = 201 uLength_A(x1,x2) = max{91, x1 - 43} uTake2_A(x1,x2,x3,x4) = max{813, x1 + 213, x2 + 426, x4 + 629} active_A(x1) = max{151, x1} nil_A = 813 uTake1_A(x1) = max{813, x1 + 586} precedence: mark = zeros = |0| = uLength = active > active# = and = tt = mark# = isNat = s = isNatIList = cons = isNatList = take = length = uTake2 = nil = uTake1 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(cons) = [] pi(isNatList) = [] pi(take) = [1] pi(length) = [] pi(zeros) = [] pi(|0|) = [] pi(uLength) = [] pi(uTake2) = [] pi(active) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p14 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p15: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p16: mark#(zeros()) -> active#(zeros()) p17: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p18: active#(uLength(tt(),L)) -> mark#(s(length(L))) p19: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p20: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p21: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p17, p18, p19, p20, p21} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1) p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p8: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p9: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p10: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p11: mark#(length(X)) -> active#(length(mark(X))) p12: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p13: mark#(s(X)) -> mark#(X) p14: mark#(isNat(X)) -> active#(isNat(X)) p15: active#(isNat(s(N))) -> mark#(isNat(N)) p16: mark#(isNatList(X)) -> active#(isNatList(X)) p17: mark#(isNatIList(X)) -> active#(isNatIList(X)) p18: mark#(and(X1,X2)) -> mark#(X2) p19: mark#(and(X1,X2)) -> mark#(X1) p20: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = x1 + 107 and_A(x1,x2) = max{26, x1, x2} tt_A = 13 mark#_A(x1) = x1 + 107 uLength_A(x1,x2) = max{170, x2 + 44} mark_A(x1) = max{25, x1} s_A(x1) = max{170, x1} length_A(x1) = max{70, x1 + 44} uTake2_A(x1,x2,x3,x4) = max{146, x1 + 15, x2 - 1} cons_A(x1,x2) = max{126, x2} isNat_A(x1) = 43 isNatList_A(x1) = 43 take_A(x1,x2) = max{57, x1 - 1} isNatIList_A(x1) = 43 active_A(x1) = max{14, x1} |0|_A = 58 zeros_A = 268 nil_A = 24 uTake1_A(x1) = max{39, x1 + 13} precedence: and = uLength = s = length = isNatList = isNatIList = |0| > take > uTake2 = zeros = uTake1 > active# = tt = mark# = mark = isNat = active = nil > cons partial status: pi(active#) = [1] pi(and) = [] pi(tt) = [] pi(mark#) = [1] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(take) = [] pi(isNatIList) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p7: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(length(X)) -> active#(length(mark(X))) p11: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(isNat(X)) -> active#(isNat(X)) p14: active#(isNat(s(N))) -> mark#(isNat(N)) p15: mark#(isNatList(X)) -> active#(isNatList(X)) p16: mark#(isNatIList(X)) -> active#(isNatIList(X)) p17: mark#(and(X1,X2)) -> mark#(X2) p18: mark#(and(X1,X2)) -> mark#(X1) p19: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2)) p16: active#(uLength(tt(),L)) -> mark#(s(length(L))) p17: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p18: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p19: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{122, x1 - 42} and_A(x1,x2) = 165 tt_A = 165 mark#_A(x1) = 123 mark_A(x1) = 258 isNat_A(x1) = 165 s_A(x1) = 165 isNatIList_A(x1) = 165 cons_A(x1,x2) = 93 isNatList_A(x1) = 165 take_A(x1,x2) = 165 length_A(x1) = 165 uLength_A(x1,x2) = 165 uTake2_A(x1,x2,x3,x4) = 165 active_A(x1) = max{256, x1 + 93} |0|_A = 4 zeros_A = 165 nil_A = 165 uTake1_A(x1) = 165 precedence: isNatIList = isNatList = uLength > active# = and = tt = mark# = mark = isNat = s = cons = take = length = uTake2 = active = |0| = zeros = nil = uTake1 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(cons) = [] pi(isNatList) = [] pi(take) = [] pi(length) = [] pi(uLength) = [] pi(uTake2) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p15 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p15: active#(uLength(tt(),L)) -> mark#(s(length(L))) p16: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p17: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p18: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4)) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p7: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(length(X)) -> active#(length(mark(X))) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(s(X)) -> mark#(X) p11: mark#(isNat(X)) -> active#(isNat(X)) p12: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p13: mark#(isNatList(X)) -> active#(isNatList(X)) p14: active#(isNat(s(N))) -> mark#(isNat(N)) p15: mark#(isNatIList(X)) -> active#(isNatIList(X)) p16: mark#(and(X1,X2)) -> mark#(X2) p17: mark#(and(X1,X2)) -> mark#(X1) p18: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{16, x1 + 15} and_A(x1,x2) = max{38, x1, x2} tt_A = 39 mark#_A(x1) = max{53, x1 + 15} uLength_A(x1,x2) = max{x1 + 33, x2 + 94} mark_A(x1) = x1 s_A(x1) = max{94, x1} length_A(x1) = x1 + 94 uTake2_A(x1,x2,x3,x4) = 33 cons_A(x1,x2) = max{33, x2} isNat_A(x1) = 40 isNatList_A(x1) = 40 take_A(x1,x2) = 33 isNatIList_A(x1) = 40 active_A(x1) = max{26, x1} |0|_A = 40 zeros_A = 130 nil_A = 27 uTake1_A(x1) = 32 precedence: and = uLength = mark = s = length = cons = isNat = isNatList = take = isNatIList = active = |0| = uTake1 > active# = tt = mark# = uTake2 = zeros = nil partial status: pi(active#) = [1] pi(and) = [] pi(tt) = [] pi(mark#) = [1] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(uTake2) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(take) = [] pi(isNatIList) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(uTake1) = [] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p5: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p6: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p7: mark#(length(X)) -> active#(length(mark(X))) p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p9: mark#(s(X)) -> mark#(X) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(isNatList(X)) -> active#(isNatList(X)) p13: active#(isNat(s(N))) -> mark#(isNat(N)) p14: mark#(isNatIList(X)) -> active#(isNatIList(X)) p15: mark#(and(X1,X2)) -> mark#(X2) p16: mark#(and(X1,X2)) -> mark#(X1) p17: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p15: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p16: active#(uLength(tt(),L)) -> mark#(s(length(L))) p17: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{1, x1 - 3} and_A(x1,x2) = max{326, x1 + 5, x2} tt_A = 223 mark#_A(x1) = max{5, x1 - 3} mark_A(x1) = x1 isNat_A(x1) = max{32, x1 + 9} s_A(x1) = max{212, x1} isNatIList_A(x1) = max{400, x1 + 219} cons_A(x1,x2) = max{148, x1 - 192, x2} isNatList_A(x1) = x1 + 219 take_A(x1,x2) = max{x1 + 115, x2 + 251} length_A(x1) = x1 + 210 uLength_A(x1,x2) = max{214, x1 - 9, x2 + 210} active_A(x1) = max{32, x1} |0|_A = 317 zeros_A = 318 nil_A = 32 uTake1_A(x1) = x1 + 32 uTake2_A(x1,x2,x3,x4) = max{x2 + 115, x3 - 75, x4 + 251} precedence: tt = s = length = |0| > isNatList > active# = and = mark# = mark = active = zeros = uTake1 = uTake2 > isNat = isNatIList = cons = take = uLength = nil partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(cons) = [] pi(isNatList) = [] pi(take) = [] pi(length) = [] pi(uLength) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p11 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: mark#(s(X)) -> mark#(X) p12: mark#(length(X)) -> active#(length(mark(X))) p13: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p14: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p15: active#(uLength(tt(),L)) -> mark#(s(length(L))) p16: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(length(X)) -> active#(length(mark(X))) p7: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p8: mark#(s(X)) -> mark#(X) p9: mark#(isNat(X)) -> active#(isNat(X)) p10: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: mark#(isNatList(X)) -> active#(isNatList(X)) p12: active#(isNat(s(N))) -> mark#(isNat(N)) p13: mark#(isNatIList(X)) -> active#(isNatIList(X)) p14: mark#(and(X1,X2)) -> mark#(X2) p15: mark#(and(X1,X2)) -> mark#(X1) p16: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = x1 + 84 and_A(x1,x2) = 344 tt_A = 343 mark#_A(x1) = 428 uLength_A(x1,x2) = 344 mark_A(x1) = 318 s_A(x1) = 95 length_A(x1) = 344 take_A(x1,x2) = 334 cons_A(x1,x2) = 317 isNat_A(x1) = 344 isNatList_A(x1) = 344 isNatIList_A(x1) = 344 active_A(x1) = 318 |0|_A = 319 zeros_A = 404 nil_A = 257 uTake1_A(x1) = 334 uTake2_A(x1,x2,x3,x4) = 333 precedence: tt = s > active# = mark# = uLength = take > and = isNatIList > mark = length = cons = isNat = isNatList = active = |0| = zeros = nil = uTake1 = uTake2 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(take) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(isNatIList) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p5: mark#(length(X)) -> active#(length(mark(X))) p6: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p7: mark#(s(X)) -> mark#(X) p8: mark#(isNat(X)) -> active#(isNat(X)) p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p10: mark#(isNatList(X)) -> active#(isNatList(X)) p11: active#(isNat(s(N))) -> mark#(isNat(N)) p12: mark#(isNatIList(X)) -> active#(isNatIList(X)) p13: mark#(and(X1,X2)) -> mark#(X2) p14: mark#(and(X1,X2)) -> mark#(X1) p15: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(isNatIList(X)) -> active#(isNatIList(X)) p7: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p10: mark#(isNat(X)) -> active#(isNat(X)) p11: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p12: mark#(s(X)) -> mark#(X) p13: mark#(length(X)) -> active#(length(mark(X))) p14: active#(uLength(tt(),L)) -> mark#(s(length(L))) p15: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{6, x1 - 4} and_A(x1,x2) = max{30, x1 + 8, x2} tt_A = 68 mark#_A(x1) = max{7, x1 - 4} mark_A(x1) = max{21, x1} isNat_A(x1) = x1 + 123 s_A(x1) = max{9, x1} isNatIList_A(x1) = x1 + 74 cons_A(x1,x2) = max{135, x1 + 96, x2} isNatList_A(x1) = x1 + 35 length_A(x1) = max{0, x1 - 10} uLength_A(x1,x2) = max{4, x1 - 46, x2 - 10} active_A(x1) = max{21, x1} |0|_A = 39 zeros_A = 136 nil_A = 68 take_A(x1,x2) = max{117, x1 + 96, x2 + 74} uTake1_A(x1) = max{20, x1} uTake2_A(x1,x2,x3,x4) = max{163, x2 + 96, x3 + 116, x4 + 74} precedence: and = mark = cons = active = nil = take > active# = mark# > isNat = s = isNatList = length = uLength = uTake1 = uTake2 > tt = isNatIList = |0| = zeros partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(cons) = [] pi(isNatList) = [] pi(length) = [] pi(uLength) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(isNatIList(X)) -> active#(isNatIList(X)) p6: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p7: mark#(isNatList(X)) -> active#(isNatList(X)) p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p9: mark#(isNat(X)) -> active#(isNat(X)) p10: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p11: mark#(s(X)) -> mark#(X) p12: mark#(length(X)) -> active#(length(mark(X))) p13: active#(uLength(tt(),L)) -> mark#(s(length(L))) p14: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p9: mark#(isNatList(X)) -> active#(isNatList(X)) p10: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL))) p11: mark#(isNatIList(X)) -> active#(isNatIList(X)) p12: active#(isNat(s(N))) -> mark#(isNat(N)) p13: mark#(and(X1,X2)) -> mark#(X2) p14: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{105, x1 + 24} and_A(x1,x2) = max{92, x2} tt_A = 99 mark#_A(x1) = x1 + 24 uLength_A(x1,x2) = x2 + 173 mark_A(x1) = max{91, x1} s_A(x1) = max{88, x1} length_A(x1) = max{173, x1 + 82} cons_A(x1,x2) = x2 + 91 isNat_A(x1) = x1 + 105 isNatList_A(x1) = x1 + 186 isNatIList_A(x1) = x1 + 186 active_A(x1) = max{91, x1} |0|_A = 92 zeros_A = 0 nil_A = 91 take_A(x1,x2) = x2 uTake1_A(x1) = 90 uTake2_A(x1,x2,x3,x4) = x4 + 91 precedence: and = tt = uLength = mark = s = length = cons = isNatList = isNatIList = active = |0| = zeros = nil = uTake2 > active# = mark# = isNat = take = uTake1 partial status: pi(active#) = [1] pi(and) = [] pi(tt) = [] pi(mark#) = [1] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(isNatIList) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p10 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p9: mark#(isNatList(X)) -> active#(isNatList(X)) p10: mark#(isNatIList(X)) -> active#(isNatIList(X)) p11: active#(isNat(s(N))) -> mark#(isNat(N)) p12: mark#(and(X1,X2)) -> mark#(X2) p13: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(isNatIList(X)) -> active#(isNatIList(X)) p6: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p7: mark#(isNatList(X)) -> active#(isNatList(X)) p8: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p9: mark#(isNat(X)) -> active#(isNat(X)) p10: active#(uLength(tt(),L)) -> mark#(s(length(L))) p11: mark#(s(X)) -> mark#(X) p12: mark#(length(X)) -> active#(length(mark(X))) p13: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{9, x1 - 300} and_A(x1,x2) = 322 tt_A = 31 mark#_A(x1) = 22 mark_A(x1) = 620 isNat_A(x1) = 322 s_A(x1) = 36 isNatIList_A(x1) = 21 isNatList_A(x1) = 322 cons_A(x1,x2) = 364 length_A(x1) = 322 uLength_A(x1,x2) = 322 active_A(x1) = max{620, x1 - 11} |0|_A = 0 zeros_A = 57 nil_A = 0 take_A(x1,x2) = 631 uTake1_A(x1) = 507 uTake2_A(x1,x2,x3,x4) = 631 precedence: isNatList > and > |0| > isNat > active# = mark# = length = uLength = uTake1 > tt = mark = s = isNatIList = cons = active = zeros = nil = take = uTake2 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatIList) = [] pi(isNatList) = [] pi(cons) = [] pi(length) = [] pi(uLength) = [] pi(active) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p5 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p6: mark#(isNatList(X)) -> active#(isNatList(X)) p7: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p8: mark#(isNat(X)) -> active#(isNat(X)) p9: active#(uLength(tt(),L)) -> mark#(s(length(L))) p10: mark#(s(X)) -> mark#(X) p11: mark#(length(X)) -> active#(length(mark(X))) p12: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L))) p9: mark#(isNatList(X)) -> active#(isNatList(X)) p10: active#(isNat(s(N))) -> mark#(isNat(N)) p11: mark#(and(X1,X2)) -> mark#(X2) p12: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{36, x1 + 33} and_A(x1,x2) = max{387, x2 + 33} tt_A = 596 mark#_A(x1) = x1 + 33 uLength_A(x1,x2) = max{x1 - 68, x2 + 301} mark_A(x1) = max{193, x1} s_A(x1) = max{373, x1 + 138} length_A(x1) = max{356, x1 + 163} cons_A(x1,x2) = max{x1 - 1, x2 + 138} isNat_A(x1) = x1 + 404 isNatList_A(x1) = x1 + 335 active_A(x1) = max{193, x1} isNatIList_A(x1) = max{657, x1 + 552} |0|_A = 192 zeros_A = 43 nil_A = 293 take_A(x1,x2) = max{476, x1 + 283, x2 + 250} uTake1_A(x1) = max{251, x1 - 302} uTake2_A(x1,x2,x3,x4) = max{656, x2 + 421, x3 - 1, x4 + 388} precedence: and = uLength > |0| = uTake1 > active# = tt = mark# = mark = s = length = cons = isNat = isNatList = active = isNatIList = zeros = nil = take = uTake2 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p8 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: mark#(isNatList(X)) -> active#(isNatList(X)) p9: active#(isNat(s(N))) -> mark#(isNat(N)) p10: mark#(and(X1,X2)) -> mark#(X2) p11: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(isNatList(X)) -> active#(isNatList(X)) p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: active#(uLength(tt(),L)) -> mark#(s(length(L))) p9: mark#(s(X)) -> mark#(X) p10: mark#(length(X)) -> active#(length(mark(X))) p11: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{12, x1 - 23} and_A(x1,x2) = 330 tt_A = 331 mark#_A(x1) = 307 mark_A(x1) = 337 isNat_A(x1) = 330 s_A(x1) = 336 isNatList_A(x1) = 225 length_A(x1) = 330 cons_A(x1,x2) = 312 uLength_A(x1,x2) = 330 active_A(x1) = max{337, x1} isNatIList_A(x1) = 59 |0|_A = 314 zeros_A = 313 nil_A = 310 take_A(x1,x2) = 303 uTake1_A(x1) = 280 uTake2_A(x1,x2,x3,x4) = 337 precedence: tt = s = uTake2 > and = nil > mark = isNatList = length = cons = uLength = active = uTake1 > |0| = zeros > active# = mark# = isNat = isNatIList = take partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(isNat) = [] pi(s) = [] pi(isNatList) = [] pi(length) = [] pi(cons) = [] pi(uLength) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p5 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(isNat(s(N))) -> mark#(isNat(N)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(isNat(X)) -> active#(isNat(X)) p7: active#(uLength(tt(),L)) -> mark#(s(length(L))) p8: mark#(s(X)) -> mark#(X) p9: mark#(length(X)) -> active#(length(mark(X))) p10: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: active#(isNat(s(N))) -> mark#(isNat(N)) p9: mark#(and(X1,X2)) -> mark#(X2) p10: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{45, x1 + 6} and_A(x1,x2) = max{42, x2} tt_A = 99 mark#_A(x1) = max{46, x1 + 6} uLength_A(x1,x2) = max{x1 + 30, x2 + 80} mark_A(x1) = max{41, x1} s_A(x1) = max{73, x1 + 7} length_A(x1) = max{115, x1 + 73} cons_A(x1,x2) = max{x1 - 30, x2 + 7} isNat_A(x1) = x1 + 40 isNatList_A(x1) = x1 + 50 active_A(x1) = max{41, x1} isNatIList_A(x1) = x1 + 151 |0|_A = 60 zeros_A = 5 nil_A = 99 take_A(x1,x2) = max{207, x1 + 143, x2 + 101} uTake1_A(x1) = max{100, x1 - 50} uTake2_A(x1,x2,x3,x4) = max{215, x2 + 150, x3 - 30, x4 + 108} precedence: length = isNatList > zeros > s = isNat > and > uLength = isNatIList > active# = tt = mark# = mark = cons = active = |0| = nil = take = uTake1 = uTake2 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p8 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(isNat(X)) -> active#(isNat(X)) p8: mark#(and(X1,X2)) -> mark#(X2) p9: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8, p9} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(isNat(X)) -> active#(isNat(X)) p6: active#(uLength(tt(),L)) -> mark#(s(length(L))) p7: mark#(s(X)) -> mark#(X) p8: mark#(length(X)) -> active#(length(mark(X))) p9: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{644, x1 - 42} and_A(x1,x2) = 688 tt_A = 1467 mark#_A(x1) = 646 mark_A(x1) = 1602 length_A(x1) = 688 cons_A(x1,x2) = 662 uLength_A(x1,x2) = 688 isNat_A(x1) = 644 isNatList_A(x1) = 796 s_A(x1) = 1536 active_A(x1) = max{1602, x1 + 66} isNatIList_A(x1) = 962 |0|_A = 1468 zeros_A = 663 nil_A = 1453 take_A(x1,x2) = 1328 uTake1_A(x1) = 1328 uTake2_A(x1,x2,x3,x4) = 1408 precedence: length = |0| > isNatList > uLength > s > active# = and = tt = mark# = mark = cons = isNat = active = isNatIList = zeros = nil = take = uTake1 = uTake2 partial status: pi(active#) = [] pi(and) = [] pi(tt) = [] pi(mark#) = [] pi(mark) = [] pi(length) = [] pi(cons) = [] pi(uLength) = [] pi(isNat) = [] pi(isNatList) = [] pi(s) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p5 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p3: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p4: mark#(and(X1,X2)) -> mark#(X2) p5: active#(uLength(tt(),L)) -> mark#(s(length(L))) p6: mark#(s(X)) -> mark#(X) p7: mark#(length(X)) -> active#(length(mark(X))) p8: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7, p8} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(and(tt(),T)) -> mark#(T) p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p6: mark#(s(X)) -> mark#(X) p7: mark#(and(X1,X2)) -> mark#(X2) p8: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: active#_A(x1) = max{1, x1} and_A(x1,x2) = max{24, x2 + 3} tt_A = 72 mark#_A(x1) = max{2, x1} uLength_A(x1,x2) = max{x1 - 26, x2 + 37} mark_A(x1) = max{8, x1} s_A(x1) = max{35, x1 + 6} length_A(x1) = max{40, x1 + 31} cons_A(x1,x2) = x2 + 6 isNat_A(x1) = max{8, x1} isNatList_A(x1) = x1 + 30 active_A(x1) = max{8, x1} isNatIList_A(x1) = x1 + 73 |0|_A = 73 zeros_A = 0 nil_A = 92 take_A(x1,x2) = max{91, x1 + 83, x2 + 82} uTake1_A(x1) = max{92, x1 + 9} uTake2_A(x1,x2,x3,x4) = max{97, x2 + 89, x4 + 88} precedence: length = isNat > isNatIList > take > uLength > tt = mark = s = cons = isNatList = active = nil = uTake1 > and = |0| > mark# = uTake2 > active# > zeros partial status: pi(active#) = [1] pi(and) = [] pi(tt) = [] pi(mark#) = [1] pi(uLength) = [] pi(mark) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(isNat) = [] pi(isNatList) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(uLength(tt(),L)) -> mark#(s(length(L))) p3: mark#(length(X)) -> active#(length(mark(X))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p5: mark#(s(X)) -> mark#(X) p6: mark#(and(X1,X2)) -> mark#(X2) p7: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p3: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2))) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) p5: mark#(and(X1,X2)) -> mark#(X2) p6: mark#(s(X)) -> mark#(X) p7: mark#(length(X)) -> active#(length(mark(X))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = 418 uLength_A(x1,x2) = 705 active#_A(x1) = max{65, x1 - 287} mark_A(x1) = 350 length_A(x1) = 705 cons_A(x1,x2) = 0 and_A(x1,x2) = 418 isNat_A(x1) = 628 isNatList_A(x1) = 303 tt_A = 588 s_A(x1) = 696 active_A(x1) = max{350, x1 - 355} isNatIList_A(x1) = 629 |0|_A = 705 zeros_A = 408 nil_A = 0 take_A(x1,x2) = 705 uTake1_A(x1) = 1 uTake2_A(x1,x2,x3,x4) = 701 precedence: length = uTake1 > mark# = uLength = active# = cons = and = tt = isNatIList = |0| = zeros = nil = take > uTake2 > mark = isNat = isNatList = s = active partial status: pi(mark#) = [] pi(uLength) = [] pi(active#) = [] pi(mark) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [] pi(tt) = [] pi(s) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) p4: mark#(and(X1,X2)) -> mark#(X2) p5: mark#(s(X)) -> mark#(X) p6: mark#(length(X)) -> active#(length(mark(X))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(uLength(tt(),L)) -> mark#(s(length(L))) p3: mark#(length(X)) -> active#(length(mark(X))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p5: mark#(s(X)) -> mark#(X) p6: mark#(and(X1,X2)) -> mark#(X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = max{1, x1 - 17} uLength_A(x1,x2) = max{565, x1 + 275, x2 + 431} active#_A(x1) = max{257, x1 - 17} mark_A(x1) = max{172, x1} tt_A = 347 s_A(x1) = max{275, x1 + 39} length_A(x1) = max{565, x1 + 392} cons_A(x1,x2) = max{157, x2 + 39} and_A(x1,x2) = max{256, x2 + 19} isNat_A(x1) = max{276, x1 + 172} isNatList_A(x1) = x1 + 136 active_A(x1) = max{172, x1} isNatIList_A(x1) = x1 + 216 |0|_A = 236 zeros_A = 132 nil_A = 346 take_A(x1,x2) = max{803, x1 + 569, x2 + 398} uTake1_A(x1) = max{804, x1 + 171} uTake2_A(x1,x2,x3,x4) = max{843, x2 + 608, x4 + 437} precedence: isNatList > tt > uTake1 > |0| > take > zeros > cons > isNat > mark = and = active = nil = uTake2 > isNatIList > uLength = length > mark# = active# > s partial status: pi(mark#) = [] pi(uLength) = [] pi(active#) = [] pi(mark) = [] pi(tt) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p6 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(uLength(tt(),L)) -> mark#(s(length(L))) p3: mark#(length(X)) -> active#(length(mark(X))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p5: mark#(s(X)) -> mark#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p3: mark#(s(X)) -> mark#(X) p4: mark#(length(X)) -> active#(length(mark(X))) p5: active#(uLength(tt(),L)) -> mark#(s(length(L))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = max{6, x1 - 3} uLength_A(x1,x2) = max{x1 + 29, x2 + 64} active#_A(x1) = max{5, x1 - 3} mark_A(x1) = max{34, x1} length_A(x1) = max{89, x1 + 54} cons_A(x1,x2) = x2 + 10 and_A(x1,x2) = max{49, x2} isNat_A(x1) = x1 + 39 isNatList_A(x1) = max{60, x1 + 35} s_A(x1) = max{57, x1 + 10} tt_A = 71 active_A(x1) = max{34, x1} isNatIList_A(x1) = max{60, x1 + 49} |0|_A = 32 zeros_A = 23 nil_A = 43 take_A(x1,x2) = max{95, x1 + 61, x2 + 34} uTake1_A(x1) = 95 uTake2_A(x1,x2,x3,x4) = max{105, x2 + 71, x4 + 44} precedence: mark = tt = active = uTake2 > and > mark# = uLength = active# = length = cons > isNat = isNatList = s > isNatIList > |0| > take = uTake1 > zeros = nil partial status: pi(mark#) = [] pi(uLength) = [] pi(active#) = [] pi(mark) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [] pi(s) = [1] pi(tt) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p3: mark#(length(X)) -> active#(length(mark(X))) p4: active#(uLength(tt(),L)) -> mark#(s(length(L))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(uLength(tt(),L)) -> mark#(s(length(L))) p3: mark#(length(X)) -> active#(length(mark(X))) p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = max{85, x1 - 11} uLength_A(x1,x2) = 3 active#_A(x1) = max{85, x1 - 25} mark_A(x1) = max{10, x1} tt_A = 57 s_A(x1) = 4 length_A(x1) = max{108, x1 + 97} cons_A(x1,x2) = max{2, x1 - 2} and_A(x1,x2) = x2 isNat_A(x1) = 122 isNatList_A(x1) = 84 active_A(x1) = max{10, x1} isNatIList_A(x1) = 84 |0|_A = 0 zeros_A = 1 nil_A = 8 take_A(x1,x2) = max{36, x1 + 26, x2 + 15} uTake1_A(x1) = 9 uTake2_A(x1,x2,x3,x4) = max{23, x3 + 12} precedence: |0| > uLength = nil > mark# = active# = tt = s = length > isNatList = uTake2 > mark = cons = isNat = active = isNatIList = zeros = take = uTake1 > and partial status: pi(mark#) = [] pi(uLength) = [] pi(active#) = [] pi(mark) = [] pi(tt) = [] pi(s) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(uLength(tt(),L)) -> mark#(s(length(L))) p3: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) p3: active#(uLength(tt(),L)) -> mark#(s(length(L))) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = max{109, x1 + 78} uLength_A(x1,x2) = max{76, x1 + 17} active#_A(x1) = x1 + 78 mark_A(x1) = max{16, x1} length_A(x1) = 76 cons_A(x1,x2) = 11 and_A(x1,x2) = max{55, x2} isNat_A(x1) = 82 isNatList_A(x1) = 59 tt_A = 15 s_A(x1) = 0 active_A(x1) = max{13, x1} isNatIList_A(x1) = 59 |0|_A = 3 zeros_A = 17 nil_A = 14 take_A(x1,x2) = 59 uTake1_A(x1) = max{16, x1} uTake2_A(x1,x2,x3,x4) = 58 precedence: isNat > isNatList > and = isNatIList = nil = take = uTake2 > uLength > mark# = active# = length > mark = cons = tt = s = active = |0| = zeros = uTake1 partial status: pi(mark#) = [] pi(uLength) = [] pi(active#) = [] pi(mark) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [] pi(tt) = [] pi(s) = [] pi(active) = [] pi(isNatIList) = [] pi(|0|) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68 Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: mark#_A(x1) = x1 + 34 uLength_A(x1,x2) = max{x1 - 68, x2 + 4} active#_A(x1) = max{38, x1 + 34} mark_A(x1) = max{4, x1} length_A(x1) = x1 cons_A(x1,x2) = max{x1, x2 + 4} and_A(x1,x2) = max{31, x2 + 1} isNat_A(x1) = max{146, x1 + 29} isNatList_A(x1) = max{32, x1 + 29} active_A(x1) = max{4, x1} tt_A = 82 isNatIList_A(x1) = x1 + 83 |0|_A = 1 s_A(x1) = max{13, x1 + 4} zeros_A = 0 nil_A = 54 take_A(x1,x2) = max{64, x1 + 55, x2 + 60} uTake1_A(x1) = max{55, x1 - 23} uTake2_A(x1,x2,x3,x4) = max{68, x2 + 59, x3 + 5, x4 + 64} precedence: mark = length = cons = isNat = active = tt = isNatIList = s = zeros = take = uTake1 > nil > uLength > and > |0| > mark# = active# = isNatList = uTake2 partial status: pi(mark#) = [1] pi(uLength) = [] pi(active#) = [1] pi(mark) = [] pi(length) = [] pi(cons) = [] pi(and) = [] pi(isNat) = [] pi(isNatList) = [1] pi(active) = [] pi(tt) = [] pi(isNatIList) = [] pi(|0|) = [] pi(s) = [] pi(zeros) = [] pi(nil) = [] pi(take) = [] pi(uTake1) = [] pi(uTake2) = [] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2)) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: (no SCCs) -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNatList#(mark(X)) -> isNatList#(X) p2: isNatList#(active(X)) -> isNatList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNatList#_A(x1) = x1 + 1 mark_A(x1) = x1 active_A(x1) = x1 precedence: isNatList# = mark = active partial status: pi(isNatList#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: isNatList#(active(X)) -> isNatList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNatList#(active(X)) -> isNatList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNatList#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: isNatList# = active partial status: pi(isNatList#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNat#(mark(X)) -> isNat#(X) p2: isNat#(active(X)) -> isNat#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNat#_A(x1) = x1 + 1 mark_A(x1) = x1 active_A(x1) = x1 precedence: isNat# = mark = active partial status: pi(isNat#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: isNat#(active(X)) -> isNat#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNat#(active(X)) -> isNat#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNat#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: isNat# = active partial status: pi(isNat#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: and#(mark(X1),X2) -> and#(X1,X2) p2: and#(X1,active(X2)) -> and#(X1,X2) p3: and#(active(X1),X2) -> and#(X1,X2) p4: and#(X1,mark(X2)) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: and#_A(x1,x2) = max{0, x2 - 2} mark_A(x1) = x1 active_A(x1) = max{3, x1 + 1} precedence: and# = mark = active partial status: pi(and#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: and#(mark(X1),X2) -> and#(X1,X2) p2: and#(active(X1),X2) -> and#(X1,X2) p3: and#(X1,mark(X2)) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: and#(mark(X1),X2) -> and#(X1,X2) p2: and#(X1,mark(X2)) -> and#(X1,X2) p3: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: and#_A(x1,x2) = max{0, x1 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 precedence: and# = mark = active partial status: pi(and#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: and#(X1,mark(X2)) -> and#(X1,X2) p2: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: and#(X1,mark(X2)) -> and#(X1,X2) p2: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: and#_A(x1,x2) = x2 + 1 mark_A(x1) = x1 + 1 active_A(x1) = x1 + 1 precedence: and# = mark = active partial status: pi(and#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: and#_A(x1,x2) = max{1, x1, x2} active_A(x1) = x1 + 1 precedence: and# = active partial status: pi(and#) = [1, 2] pi(active) = [] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNatIList#(mark(X)) -> isNatIList#(X) p2: isNatIList#(active(X)) -> isNatIList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNatIList#_A(x1) = x1 + 1 mark_A(x1) = x1 active_A(x1) = x1 precedence: isNatIList# = mark = active partial status: pi(isNatIList#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: isNatIList#(active(X)) -> isNatIList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNatIList#(active(X)) -> isNatIList#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: isNatIList#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: isNatIList# = active partial status: pi(isNatIList#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake1#(mark(X)) -> uTake1#(X) p2: uTake1#(active(X)) -> uTake1#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake1#_A(x1) = max{3, x1 + 2} mark_A(x1) = x1 active_A(x1) = x1 + 1 precedence: uTake1# = mark = active partial status: pi(uTake1#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake1#(active(X)) -> uTake1#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake1#(active(X)) -> uTake1#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake1#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: uTake1# = active partial status: pi(uTake1#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p6: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4) p7: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p8: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{0, x2 - 2} mark_A(x1) = x1 active_A(x1) = max{3, x1 + 1} precedence: uTake2# = mark = active partial status: pi(uTake2#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4) p6: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p7: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6, p7} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p6: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p7: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{0, x4 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 precedence: uTake2# > mark = active partial status: pi(uTake2#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p4 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p6: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5, p6} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p6: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = x2 + 1 mark_A(x1) = x1 + 1 active_A(x1) = x1 + 1 precedence: uTake2# = mark = active partial status: pi(uTake2#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p6 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4, p5} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p5: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{x1 - 1, x2 + 1, x3 - 1, x4 + 1} mark_A(x1) = x1 active_A(x1) = x1 precedence: uTake2# = mark = active partial status: pi(uTake2#) = [4] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p5 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3, p4} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p4: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{0, x3 - 2} mark_A(x1) = x1 active_A(x1) = max{3, x1 + 1} precedence: uTake2# = mark = active partial status: pi(uTake2#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) p3: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{x1, x2, x4 + 1} mark_A(x1) = x1 + 1 active_A(x1) = x1 precedence: uTake2# = mark = active partial status: pi(uTake2#) = [1, 2] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p3 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{x1 - 1, x3 + 1, x4 + 1} mark_A(x1) = x1 precedence: uTake2# = mark partial status: pi(uTake2#) = [3] pi(mark) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uTake2#_A(x1,x2,x3,x4) = max{x1, x2 + 1, x3 + 1, x4 + 1} mark_A(x1) = max{1, x1} precedence: uTake2# = mark partial status: pi(uTake2#) = [1, 2] pi(mark) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: cons#(mark(X1),X2) -> cons#(X1,X2) p2: cons#(X1,active(X2)) -> cons#(X1,X2) p3: cons#(active(X1),X2) -> cons#(X1,X2) p4: cons#(X1,mark(X2)) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: cons#_A(x1,x2) = max{0, x2 - 2} mark_A(x1) = x1 active_A(x1) = max{3, x1 + 1} precedence: cons# = mark = active partial status: pi(cons#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: cons#(mark(X1),X2) -> cons#(X1,X2) p2: cons#(active(X1),X2) -> cons#(X1,X2) p3: cons#(X1,mark(X2)) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: cons#(mark(X1),X2) -> cons#(X1,X2) p2: cons#(X1,mark(X2)) -> cons#(X1,X2) p3: cons#(active(X1),X2) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: cons#_A(x1,x2) = max{0, x1 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 precedence: cons# = mark = active partial status: pi(cons#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: cons#(X1,mark(X2)) -> cons#(X1,X2) p2: cons#(active(X1),X2) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: cons#(X1,mark(X2)) -> cons#(X1,X2) p2: cons#(active(X1),X2) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: cons#_A(x1,x2) = x2 + 1 mark_A(x1) = x1 + 1 active_A(x1) = x1 + 1 precedence: cons# = mark = active partial status: pi(cons#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: cons#(active(X1),X2) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: cons#(active(X1),X2) -> cons#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: cons#_A(x1,x2) = max{1, x1, x2} active_A(x1) = x1 + 1 precedence: cons# = active partial status: pi(cons#) = [1, 2] pi(active) = [] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: take#(mark(X1),X2) -> take#(X1,X2) p2: take#(X1,active(X2)) -> take#(X1,X2) p3: take#(active(X1),X2) -> take#(X1,X2) p4: take#(X1,mark(X2)) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: take#_A(x1,x2) = max{0, x2 - 1} mark_A(x1) = x1 active_A(x1) = x1 + 2 precedence: take# = mark = active partial status: pi(take#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: take#(mark(X1),X2) -> take#(X1,X2) p2: take#(active(X1),X2) -> take#(X1,X2) p3: take#(X1,mark(X2)) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: take#(mark(X1),X2) -> take#(X1,X2) p2: take#(X1,mark(X2)) -> take#(X1,X2) p3: take#(active(X1),X2) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: take#_A(x1,x2) = max{0, x1 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 precedence: take# = mark = active partial status: pi(take#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: take#(X1,mark(X2)) -> take#(X1,X2) p2: take#(active(X1),X2) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: take#(X1,mark(X2)) -> take#(X1,X2) p2: take#(active(X1),X2) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: take#_A(x1,x2) = max{0, x2 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 + 1 precedence: take# = mark = active partial status: pi(take#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: take#(active(X1),X2) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: take#(active(X1),X2) -> take#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: take#_A(x1,x2) = max{1, x1, x2} active_A(x1) = x1 + 1 precedence: take# = active partial status: pi(take#) = [1, 2] pi(active) = [] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(mark(X1),X2) -> uLength#(X1,X2) p2: uLength#(X1,active(X2)) -> uLength#(X1,X2) p3: uLength#(active(X1),X2) -> uLength#(X1,X2) p4: uLength#(X1,mark(X2)) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uLength#_A(x1,x2) = max{0, x2 - 1} mark_A(x1) = x1 active_A(x1) = x1 + 2 precedence: uLength# = mark = active partial status: pi(uLength#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p2 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(mark(X1),X2) -> uLength#(X1,X2) p2: uLength#(active(X1),X2) -> uLength#(X1,X2) p3: uLength#(X1,mark(X2)) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2, p3} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(mark(X1),X2) -> uLength#(X1,X2) p2: uLength#(X1,mark(X2)) -> uLength#(X1,X2) p3: uLength#(active(X1),X2) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uLength#_A(x1,x2) = max{0, x1 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 precedence: uLength# = mark = active partial status: pi(uLength#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(X1,mark(X2)) -> uLength#(X1,X2) p2: uLength#(active(X1),X2) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1, p2} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(X1,mark(X2)) -> uLength#(X1,X2) p2: uLength#(active(X1),X2) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uLength#_A(x1,x2) = max{0, x2 - 2} mark_A(x1) = max{3, x1 + 1} active_A(x1) = x1 + 1 precedence: uLength# = mark = active partial status: pi(uLength#) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(active(X1),X2) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: uLength#(active(X1),X2) -> uLength#(X1,X2) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: max/plus interpretations on natural numbers: uLength#_A(x1,x2) = max{1, x1, x2} active_A(x1) = x1 + 1 precedence: uLength# = active partial status: pi(uLength#) = [1, 2] pi(active) = [] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: s#(mark(X)) -> s#(X) p2: s#(active(X)) -> s#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: s#_A(x1) = max{3, x1 + 2} mark_A(x1) = x1 active_A(x1) = x1 + 1 precedence: s# = mark = active partial status: pi(s#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: s#(active(X)) -> s#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: s#(active(X)) -> s#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: s#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: s# = active partial status: pi(s#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains. -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: length#(mark(X)) -> length#(X) p2: length#(active(X)) -> length#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: length#_A(x1) = x1 + 1 mark_A(x1) = x1 active_A(x1) = x1 precedence: length# = mark = active partial status: pi(length#) = [1] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: length#(active(X)) -> length#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: length#(active(X)) -> length#(X) and R consists of: r1: active(and(tt(),T)) -> mark(T) r2: active(isNatIList(IL)) -> mark(isNatList(IL)) r3: active(isNat(|0|())) -> mark(tt()) r4: active(isNat(s(N))) -> mark(isNat(N)) r5: active(isNat(length(L))) -> mark(isNatList(L)) r6: active(isNatIList(zeros())) -> mark(tt()) r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r8: active(isNatList(nil())) -> mark(tt()) r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L))) r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL))) r11: active(zeros()) -> mark(cons(|0|(),zeros())) r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL))) r13: active(uTake1(tt())) -> mark(nil()) r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)) r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL))) r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L)) r17: active(uLength(tt(),L)) -> mark(s(length(L))) r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2))) r19: mark(tt()) -> active(tt()) r20: mark(isNatIList(X)) -> active(isNatIList(X)) r21: mark(isNatList(X)) -> active(isNatList(X)) r22: mark(isNat(X)) -> active(isNat(X)) r23: mark(|0|()) -> active(|0|()) r24: mark(s(X)) -> active(s(mark(X))) r25: mark(length(X)) -> active(length(mark(X))) r26: mark(zeros()) -> active(zeros()) r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2)) r28: mark(nil()) -> active(nil()) r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2))) r30: mark(uTake1(X)) -> active(uTake1(mark(X))) r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4)) r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2)) r33: and(mark(X1),X2) -> and(X1,X2) r34: and(X1,mark(X2)) -> and(X1,X2) r35: and(active(X1),X2) -> and(X1,X2) r36: and(X1,active(X2)) -> and(X1,X2) r37: isNatIList(mark(X)) -> isNatIList(X) r38: isNatIList(active(X)) -> isNatIList(X) r39: isNatList(mark(X)) -> isNatList(X) r40: isNatList(active(X)) -> isNatList(X) r41: isNat(mark(X)) -> isNat(X) r42: isNat(active(X)) -> isNat(X) r43: s(mark(X)) -> s(X) r44: s(active(X)) -> s(X) r45: length(mark(X)) -> length(X) r46: length(active(X)) -> length(X) r47: cons(mark(X1),X2) -> cons(X1,X2) r48: cons(X1,mark(X2)) -> cons(X1,X2) r49: cons(active(X1),X2) -> cons(X1,X2) r50: cons(X1,active(X2)) -> cons(X1,X2) r51: take(mark(X1),X2) -> take(X1,X2) r52: take(X1,mark(X2)) -> take(X1,X2) r53: take(active(X1),X2) -> take(X1,X2) r54: take(X1,active(X2)) -> take(X1,X2) r55: uTake1(mark(X)) -> uTake1(X) r56: uTake1(active(X)) -> uTake1(X) r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4) r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4) r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4) r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4) r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4) r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4) r65: uLength(mark(X1),X2) -> uLength(X1,X2) r66: uLength(X1,mark(X2)) -> uLength(X1,X2) r67: uLength(active(X1),X2) -> uLength(X1,X2) r68: uLength(X1,active(X2)) -> uLength(X1,X2) The set of usable rules consists of (no rules) Take the monotone reduction pair: weighted path order base order: max/plus interpretations on natural numbers: length#_A(x1) = x1 + 1 active_A(x1) = x1 precedence: length# = active partial status: pi(length#) = [1] pi(active) = [1] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains.