YES We show the termination of the TRS R: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) active(__(X,nil())) -> mark(X) active(__(nil(),X)) -> mark(X) active(and(tt(),X)) -> mark(X) active(isList(V)) -> mark(isNeList(V)) active(isList(nil())) -> mark(tt()) active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) active(isNeList(V)) -> mark(isQid(V)) active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) active(isNePal(V)) -> mark(isQid(V)) active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) active(isPal(V)) -> mark(isNePal(V)) active(isPal(nil())) -> mark(tt()) active(isQid(a())) -> mark(tt()) active(isQid(e())) -> mark(tt()) active(isQid(i())) -> mark(tt()) active(isQid(o())) -> mark(tt()) active(isQid(u())) -> mark(tt()) mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) mark(nil()) -> active(nil()) mark(and(X1,X2)) -> active(and(mark(X1),X2)) mark(tt()) -> active(tt()) mark(isList(X)) -> active(isList(X)) mark(isNeList(X)) -> active(isNeList(X)) mark(isQid(X)) -> active(isQid(X)) mark(isNePal(X)) -> active(isNePal(X)) mark(isPal(X)) -> active(isPal(X)) mark(a()) -> active(a()) mark(e()) -> active(e()) mark(i()) -> active(i()) mark(o()) -> active(o()) mark(u()) -> active(u()) __(mark(X1),X2) -> __(X1,X2) __(X1,mark(X2)) -> __(X1,X2) __(active(X1),X2) -> __(X1,X2) __(X1,active(X2)) -> __(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) isList(mark(X)) -> isList(X) isList(active(X)) -> isList(X) isNeList(mark(X)) -> isNeList(X) isNeList(active(X)) -> isNeList(X) isQid(mark(X)) -> isQid(X) isQid(active(X)) -> isQid(X) isNePal(mark(X)) -> isNePal(X) isNePal(active(X)) -> isNePal(X) isPal(mark(X)) -> isPal(X) isPal(active(X)) -> isPal(X) -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: active#(__(__(X,Y),Z)) -> __#(X,__(Y,Z)) p3: active#(__(__(X,Y),Z)) -> __#(Y,Z) p4: active#(__(X,nil())) -> mark#(X) p5: active#(__(nil(),X)) -> mark#(X) p6: active#(and(tt(),X)) -> mark#(X) p7: active#(isList(V)) -> mark#(isNeList(V)) p8: active#(isList(V)) -> isNeList#(V) p9: active#(isList(nil())) -> mark#(tt()) p10: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p11: active#(isList(__(V1,V2))) -> and#(isList(V1),isList(V2)) p12: active#(isList(__(V1,V2))) -> isList#(V1) p13: active#(isList(__(V1,V2))) -> isList#(V2) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: active#(isNeList(V)) -> isQid#(V) p16: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p17: active#(isNeList(__(V1,V2))) -> and#(isList(V1),isNeList(V2)) p18: active#(isNeList(__(V1,V2))) -> isList#(V1) p19: active#(isNeList(__(V1,V2))) -> isNeList#(V2) p20: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p21: active#(isNeList(__(V1,V2))) -> and#(isNeList(V1),isList(V2)) p22: active#(isNeList(__(V1,V2))) -> isNeList#(V1) p23: active#(isNeList(__(V1,V2))) -> isList#(V2) p24: active#(isNePal(V)) -> mark#(isQid(V)) p25: active#(isNePal(V)) -> isQid#(V) p26: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p27: active#(isNePal(__(I,__(P,I)))) -> and#(isQid(I),isPal(P)) p28: active#(isNePal(__(I,__(P,I)))) -> isQid#(I) p29: active#(isNePal(__(I,__(P,I)))) -> isPal#(P) p30: active#(isPal(V)) -> mark#(isNePal(V)) p31: active#(isPal(V)) -> isNePal#(V) p32: active#(isPal(nil())) -> mark#(tt()) p33: active#(isQid(a())) -> mark#(tt()) p34: active#(isQid(e())) -> mark#(tt()) p35: active#(isQid(i())) -> mark#(tt()) p36: active#(isQid(o())) -> mark#(tt()) p37: active#(isQid(u())) -> mark#(tt()) p38: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p39: mark#(__(X1,X2)) -> __#(mark(X1),mark(X2)) p40: mark#(__(X1,X2)) -> mark#(X1) p41: mark#(__(X1,X2)) -> mark#(X2) p42: mark#(nil()) -> active#(nil()) p43: mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) p44: mark#(and(X1,X2)) -> and#(mark(X1),X2) p45: mark#(and(X1,X2)) -> mark#(X1) p46: mark#(tt()) -> active#(tt()) p47: mark#(isList(X)) -> active#(isList(X)) p48: mark#(isNeList(X)) -> active#(isNeList(X)) p49: mark#(isQid(X)) -> active#(isQid(X)) p50: mark#(isNePal(X)) -> active#(isNePal(X)) p51: mark#(isPal(X)) -> active#(isPal(X)) p52: mark#(a()) -> active#(a()) p53: mark#(e()) -> active#(e()) p54: mark#(i()) -> active#(i()) p55: mark#(o()) -> active#(o()) p56: mark#(u()) -> active#(u()) p57: __#(mark(X1),X2) -> __#(X1,X2) p58: __#(X1,mark(X2)) -> __#(X1,X2) p59: __#(active(X1),X2) -> __#(X1,X2) p60: __#(X1,active(X2)) -> __#(X1,X2) p61: and#(mark(X1),X2) -> and#(X1,X2) p62: and#(X1,mark(X2)) -> and#(X1,X2) p63: and#(active(X1),X2) -> and#(X1,X2) p64: and#(X1,active(X2)) -> and#(X1,X2) p65: isList#(mark(X)) -> isList#(X) p66: isList#(active(X)) -> isList#(X) p67: isNeList#(mark(X)) -> isNeList#(X) p68: isNeList#(active(X)) -> isNeList#(X) p69: isQid#(mark(X)) -> isQid#(X) p70: isQid#(active(X)) -> isQid#(X) p71: isNePal#(mark(X)) -> isNePal#(X) p72: isNePal#(active(X)) -> isNePal#(X) p73: isPal#(mark(X)) -> isPal#(X) p74: isPal#(active(X)) -> isPal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1, p4, p5, p6, p7, p10, p14, p16, p20, p24, p26, p30, p38, p40, p41, p43, p45, p47, p48, p49, p50, p51} {p57, p58, p59, p60} {p67, p68} {p61, p62, p63, p64} {p65, p66} {p69, p70} {p73, p74} {p71, p72} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(and(X1,X2)) -> active#(and(mark(X1),X2)) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: mark#(__(X1,X2)) -> mark#(X2) p16: mark#(__(X1,X2)) -> mark#(X1) p17: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p18: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p19: active#(isList(V)) -> mark#(isNeList(V)) p20: active#(and(tt(),X)) -> mark#(X) p21: active#(__(nil(),X)) -> mark#(X) p22: active#(__(X,nil())) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 + (0,2) ___A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(0,0)) x2 + (19,0) mark#_A(x1) = x1 + (0,3) isPal_A(x1) = ((0,0),(1,0)) x1 + (19,4) isNePal_A(x1) = ((0,0),(1,0)) x1 + (19,0) and_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (0,3) isQid_A(x1) = (0,1) isNeList_A(x1) = ((1,0),(0,0)) x1 + (1,5) isList_A(x1) = ((1,0),(1,0)) x1 + (2,8) mark_A(x1) = x1 tt_A() = (0,0) nil_A() = (0,4) active_A(x1) = x1 a_A() = (1,0) e_A() = (0,0) i_A() = (0,1) o_A() = (1,1) u_A() = (0,1) precedence: mark = nil = active > and = isQid > active# = mark# > __ = isPal = isNePal > tt = a = e = i = u > isNeList = isList = o partial status: pi(active#) = [1] pi(__) = [] pi(mark#) = [1] pi(isPal) = [] pi(isNePal) = [] pi(and) = [1] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(mark) = [] pi(tt) = [] pi(nil) = [] pi(active) = [] pi(a) = [] pi(e) = [] pi(i) = [] pi(o) = [] pi(u) = [] The next rules are strictly ordered: p13 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: active#(isNeList(V)) -> mark#(isQid(V)) p14: mark#(__(X1,X2)) -> mark#(X2) p15: mark#(__(X1,X2)) -> mark#(X1) p16: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p17: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p18: active#(isList(V)) -> mark#(isNeList(V)) p19: active#(and(tt(),X)) -> mark#(X) p20: active#(__(nil(),X)) -> mark#(X) p21: active#(__(X,nil())) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p3: active#(__(X,nil())) -> mark#(X) p4: mark#(__(X1,X2)) -> mark#(X1) p5: mark#(__(X1,X2)) -> mark#(X2) p6: mark#(and(X1,X2)) -> mark#(X1) p7: mark#(isList(X)) -> active#(isList(X)) p8: active#(__(nil(),X)) -> mark#(X) p9: mark#(isNeList(X)) -> active#(isNeList(X)) p10: active#(and(tt(),X)) -> mark#(X) p11: mark#(isQid(X)) -> active#(isQid(X)) p12: active#(isList(V)) -> mark#(isNeList(V)) p13: mark#(isNePal(X)) -> active#(isNePal(X)) p14: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p15: mark#(isPal(X)) -> active#(isPal(X)) p16: active#(isNeList(V)) -> mark#(isQid(V)) p17: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p18: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p19: active#(isNePal(V)) -> mark#(isQid(V)) p20: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p21: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = ((0,0),(1,0)) x1 + (1,1) ___A(x1,x2) = (7,5) mark#_A(x1) = (1,8) mark_A(x1) = (9,7) nil_A() = (2,0) and_A(x1,x2) = (8,6) isList_A(x1) = (7,9) isNeList_A(x1) = (7,3) tt_A() = (3,3) isQid_A(x1) = (1,3) isNePal_A(x1) = (7,8) isPal_A(x1) = (7,4) active_A(x1) = (9,7) a_A() = (10,0) e_A() = (10,8) i_A() = (10,8) o_A() = (1,0) u_A() = (10,0) precedence: isNeList > __ = mark = isQid = isPal = active = u > nil > e > active# = mark# > tt = a > i = o > and > isNePal > isList partial status: pi(active#) = [] pi(__) = [] pi(mark#) = [] pi(mark) = [] pi(nil) = [] pi(and) = [] pi(isList) = [] pi(isNeList) = [] pi(tt) = [] pi(isQid) = [] pi(isNePal) = [] pi(isPal) = [] pi(active) = [] pi(a) = [] pi(e) = [] pi(i) = [] pi(o) = [] pi(u) = [] 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p3: active#(__(X,nil())) -> mark#(X) p4: mark#(__(X1,X2)) -> mark#(X1) p5: mark#(__(X1,X2)) -> mark#(X2) p6: mark#(and(X1,X2)) -> mark#(X1) p7: mark#(isList(X)) -> active#(isList(X)) p8: active#(__(nil(),X)) -> mark#(X) p9: mark#(isNeList(X)) -> active#(isNeList(X)) p10: mark#(isQid(X)) -> active#(isQid(X)) p11: active#(isList(V)) -> mark#(isNeList(V)) p12: mark#(isNePal(X)) -> active#(isNePal(X)) p13: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p14: mark#(isPal(X)) -> active#(isPal(X)) p15: active#(isNeList(V)) -> mark#(isQid(V)) p16: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p17: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p18: active#(isNePal(V)) -> mark#(isQid(V)) p19: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p20: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: mark#(__(X1,X2)) -> mark#(X1) p15: mark#(__(X1,X2)) -> active#(__(mark(X1),mark(X2))) p16: active#(isNeList(V)) -> mark#(isQid(V)) p17: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p18: active#(isList(V)) -> mark#(isNeList(V)) p19: active#(__(nil(),X)) -> mark#(X) p20: active#(__(X,nil())) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 ___A(x1,x2) = x1 + ((1,0),(1,0)) x2 + (12,19) mark#_A(x1) = x1 + (0,3) isPal_A(x1) = ((1,0),(0,0)) x1 + (11,15) isNePal_A(x1) = ((1,0),(0,0)) x1 + (1,11) and_A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (2,4) isQid_A(x1) = ((1,0),(0,0)) x1 + (0,3) isNeList_A(x1) = ((1,0),(1,0)) x1 + (0,7) isList_A(x1) = ((1,0),(1,0)) x1 + (0,11) mark_A(x1) = x1 + (0,2) nil_A() = (2,12) active_A(x1) = x1 tt_A() = (1,11) a_A() = (2,14) e_A() = (2,14) i_A() = (2,14) o_A() = (2,14) u_A() = (2,14) precedence: active# = isPal = isNePal = and = isQid = isNeList = isList = mark = active = tt = a = e > __ > mark# > nil = o > i = u partial status: pi(active#) = [] pi(__) = [1] pi(mark#) = [1] pi(isPal) = [] pi(isNePal) = [] pi(and) = [] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(mark) = [] pi(nil) = [] pi(active) = [] pi(tt) = [] pi(a) = [] pi(e) = [] pi(i) = [] pi(o) = [] pi(u) = [] 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: mark#(__(X1,X2)) -> mark#(X1) p15: active#(isNeList(V)) -> mark#(isQid(V)) p16: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p17: active#(isList(V)) -> mark#(isNeList(V)) p18: active#(__(nil(),X)) -> mark#(X) p19: active#(__(X,nil())) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X1) p3: mark#(__(X1,X2)) -> mark#(X2) p4: mark#(and(X1,X2)) -> mark#(X1) p5: mark#(isList(X)) -> active#(isList(X)) p6: active#(__(X,nil())) -> mark#(X) p7: mark#(isNeList(X)) -> active#(isNeList(X)) p8: active#(__(nil(),X)) -> mark#(X) p9: mark#(isQid(X)) -> active#(isQid(X)) p10: active#(isList(V)) -> mark#(isNeList(V)) p11: mark#(isNePal(X)) -> active#(isNePal(X)) p12: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p13: mark#(isPal(X)) -> active#(isPal(X)) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p16: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p17: active#(isNePal(V)) -> mark#(isQid(V)) p18: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p19: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 + (2,1) ___A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (13,7) mark#_A(x1) = ((1,0),(0,0)) x1 + (2,6) and_A(x1,x2) = ((1,0),(0,0)) x1 + (6,1) isList_A(x1) = ((1,0),(0,0)) x1 + (4,4) nil_A() = (0,1) isNeList_A(x1) = ((1,0),(0,0)) x1 + (3,2) isQid_A(x1) = (0,4) isNePal_A(x1) = ((1,0),(0,0)) x1 + (0,5) isPal_A(x1) = ((1,0),(0,0)) x1 + (0,5) mark_A(x1) = ((1,0),(1,1)) x1 + (5,8) active_A(x1) = ((1,0),(1,1)) x1 + (7,8) precedence: __ = and = isNeList = active > active# = mark# > nil = isQid = isNePal = isPal > isList = mark partial status: pi(active#) = [] pi(__) = [] pi(mark#) = [] pi(and) = [] pi(isList) = [] pi(nil) = [] pi(isNeList) = [] pi(isQid) = [] pi(isNePal) = [] pi(isPal) = [] pi(mark) = [1] pi(active) = [] 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: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(__(X,nil())) -> mark#(X) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(__(nil(),X)) -> mark#(X) p8: mark#(isQid(X)) -> active#(isQid(X)) p9: active#(isList(V)) -> mark#(isNeList(V)) p10: mark#(isNePal(X)) -> active#(isNePal(X)) p11: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p12: mark#(isPal(X)) -> active#(isPal(X)) p13: active#(isNeList(V)) -> mark#(isQid(V)) p14: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p15: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p16: active#(isNePal(V)) -> mark#(isQid(V)) p17: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p18: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p16: active#(isList(V)) -> mark#(isNeList(V)) p17: active#(__(nil(),X)) -> mark#(X) p18: active#(__(X,nil())) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = ((0,0),(1,0)) x1 + (7,3) ___A(x1,x2) = ((1,0),(1,0)) x1 + (5,14) mark#_A(x1) = (7,6) isPal_A(x1) = ((0,0),(1,0)) x1 + (3,0) isNePal_A(x1) = ((0,0),(1,0)) x1 + (3,0) and_A(x1,x2) = ((1,0),(0,0)) x2 + (3,0) isQid_A(x1) = ((0,0),(1,0)) x1 + (2,0) isNeList_A(x1) = (3,15) isList_A(x1) = (3,0) nil_A() = (0,0) mark_A(x1) = ((1,0),(1,0)) x1 + (6,16) active_A(x1) = ((1,0),(1,0)) x1 + (4,0) precedence: __ = isNePal = and = isNeList = isList = mark > active# = mark# > isPal > isQid > nil > active partial status: pi(active#) = [] pi(__) = [] pi(mark#) = [] pi(isPal) = [] pi(isNePal) = [] pi(and) = [] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(nil) = [] pi(mark) = [] pi(active) = [] 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p16: active#(isList(V)) -> mark#(isNeList(V)) p17: active#(__(nil(),X)) -> mark#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(__(nil(),X)) -> mark#(X) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isList(V)) -> mark#(isNeList(V)) p8: mark#(isQid(X)) -> active#(isQid(X)) p9: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p10: mark#(isNePal(X)) -> active#(isNePal(X)) p11: active#(isNeList(V)) -> mark#(isQid(V)) p12: mark#(isPal(X)) -> active#(isPal(X)) p13: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p14: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p15: active#(isNePal(V)) -> mark#(isQid(V)) p16: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p17: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 + (1,0) ___A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (3,17) mark#_A(x1) = ((1,0),(1,0)) x1 + (1,7) and_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,2) isList_A(x1) = ((1,0),(1,0)) x1 + (9,16) nil_A() = (2,1) isNeList_A(x1) = ((1,0),(1,0)) x1 + (9,15) isQid_A(x1) = ((1,0),(0,0)) x1 + (1,2) isNePal_A(x1) = ((1,0),(1,0)) x1 + (9,9) isPal_A(x1) = ((1,0),(1,0)) x1 + (10,16) mark_A(x1) = ((1,0),(1,1)) x1 + (4,1) active_A(x1) = ((1,0),(1,1)) x1 + (2,0) precedence: active# = mark# = isList = isNeList = isNePal = isPal > nil > __ = isQid > mark > and = active partial status: pi(active#) = [] pi(__) = [1] pi(mark#) = [] pi(and) = [1] pi(isList) = [] pi(nil) = [] pi(isNeList) = [] pi(isQid) = [] pi(isNePal) = [] pi(isPal) = [] 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: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(V)) -> mark#(isNeList(V)) p7: mark#(isQid(X)) -> active#(isQid(X)) p8: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p9: mark#(isNePal(X)) -> active#(isNePal(X)) p10: active#(isNeList(V)) -> mark#(isQid(V)) p11: mark#(isPal(X)) -> active#(isPal(X)) p12: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p13: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p14: active#(isNePal(V)) -> mark#(isQid(V)) p15: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p16: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNePal(V)) -> mark#(isQid(V)) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: active#(isNeList(V)) -> mark#(isQid(V)) p15: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p16: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = ((1,0),(0,0)) x1 + (3,15) ___A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (4,30) mark#_A(x1) = ((0,0),(1,0)) x1 + (5,13) isPal_A(x1) = ((0,0),(1,0)) x1 + (2,2) isNePal_A(x1) = ((0,0),(1,0)) x1 + (2,1) and_A(x1,x2) = x1 + ((0,0),(1,0)) x2 + (0,12) isQid_A(x1) = ((0,0),(1,0)) x1 + (1,10) isNeList_A(x1) = (2,0) isList_A(x1) = (2,15) mark_A(x1) = ((1,0),(1,1)) x1 + (3,11) active_A(x1) = ((1,0),(0,0)) x1 + (3,3) precedence: active# = mark# > __ > isQid = isNeList = isList > isPal = isNePal = and = mark = active partial status: pi(active#) = [] pi(__) = [1] pi(mark#) = [] pi(isPal) = [] pi(isNePal) = [] pi(and) = [] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(mark) = [1] pi(active) = [] The next rules are strictly ordered: p7 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: mark#(isNeList(X)) -> active#(isNeList(X)) p8: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p9: mark#(isList(X)) -> active#(isList(X)) p10: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p11: mark#(and(X1,X2)) -> mark#(X1) p12: mark#(__(X1,X2)) -> mark#(X2) p13: active#(isNeList(V)) -> mark#(isQid(V)) p14: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p15: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(isList(V)) -> mark#(isNeList(V)) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p8: mark#(isQid(X)) -> active#(isQid(X)) p9: active#(isNeList(V)) -> mark#(isQid(V)) p10: mark#(isNePal(X)) -> active#(isNePal(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(isPal(X)) -> active#(isPal(X)) p13: active#(isNeList(__(V1,V2))) -> mark#(and(isNeList(V1),isList(V2))) p14: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p15: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 + (2,2) ___A(x1,x2) = x1 + ((1,0),(1,1)) x2 + (11,9) mark#_A(x1) = ((1,0),(0,0)) x1 + (2,17) and_A(x1,x2) = x1 + (3,20) isList_A(x1) = ((1,0),(0,0)) x1 + (5,14) isNeList_A(x1) = ((1,0),(0,0)) x1 + (2,11) isQid_A(x1) = (1,10) isNePal_A(x1) = ((1,0),(0,0)) x1 + (0,7) isPal_A(x1) = ((1,0),(0,0)) x1 + (5,6) mark_A(x1) = ((1,0),(1,1)) x1 + (6,15) active_A(x1) = ((1,0),(0,0)) x1 + (12,15) precedence: active > active# = __ = mark# = and = isNeList = isQid > isNePal = isPal = mark > isList partial status: pi(active#) = [] pi(__) = [1, 2] pi(mark#) = [] pi(and) = [] pi(isList) = [] pi(isNeList) = [] pi(isQid) = [] pi(isNePal) = [] pi(isPal) = [] pi(mark) = [1] pi(active) = [] The next rules are strictly ordered: p13 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(isList(V)) -> mark#(isNeList(V)) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p8: mark#(isQid(X)) -> active#(isQid(X)) p9: active#(isNeList(V)) -> mark#(isQid(V)) p10: mark#(isNePal(X)) -> active#(isNePal(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: mark#(isPal(X)) -> active#(isPal(X)) p13: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p14: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isQid(X)) -> active#(isQid(X)) p7: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p8: mark#(isNeList(X)) -> active#(isNeList(X)) p9: active#(isNeList(V)) -> mark#(isQid(V)) p10: mark#(isList(X)) -> active#(isList(X)) p11: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p12: mark#(and(X1,X2)) -> mark#(X1) p13: mark#(__(X1,X2)) -> mark#(X2) p14: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = ((0,0),(1,0)) x1 + (6,9) ___A(x1,x2) = (5,9) mark#_A(x1) = (6,12) isPal_A(x1) = ((0,0),(1,0)) x1 + (3,13) isNePal_A(x1) = ((0,0),(1,0)) x1 + (3,1) and_A(x1,x2) = ((1,0),(0,0)) x1 + (1,1) isQid_A(x1) = ((0,0),(1,0)) x1 + (1,7) isNeList_A(x1) = ((0,0),(1,0)) x1 + (3,8) isList_A(x1) = ((0,0),(1,0)) x1 + (3,11) mark_A(x1) = ((1,0),(1,1)) x1 + (6,14) active_A(x1) = ((1,0),(1,0)) x1 + (6,14) precedence: active# = __ = mark# = isPal = isNePal = and = isQid = isNeList = isList = mark = active partial status: pi(active#) = [] pi(__) = [] pi(mark#) = [] pi(isPal) = [] pi(isNePal) = [] pi(and) = [] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(mark) = [1] pi(active) = [] 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: active#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p7: mark#(isNeList(X)) -> active#(isNeList(X)) p8: active#(isNeList(V)) -> mark#(isQid(V)) p9: mark#(isList(X)) -> active#(isList(X)) p10: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p11: mark#(and(X1,X2)) -> mark#(X1) p12: mark#(__(X1,X2)) -> mark#(X2) p13: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(__(__(X,Y),Z)) -> mark#(__(X,__(Y,Z))) p2: mark#(__(X1,X2)) -> mark#(X2) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(isList(V)) -> mark#(isNeList(V)) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p8: mark#(isNePal(X)) -> active#(isNePal(X)) p9: active#(isNeList(V)) -> mark#(isQid(V)) p10: mark#(isPal(X)) -> active#(isPal(X)) p11: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p12: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p13: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = ((1,0),(0,0)) x1 + (1,3) ___A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (4,0) mark#_A(x1) = (3,3) and_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (1,7) isList_A(x1) = ((0,0),(1,0)) x1 + (2,13) isNeList_A(x1) = ((0,0),(1,0)) x1 + (2,8) isNePal_A(x1) = ((0,0),(1,0)) x1 + (2,7) isQid_A(x1) = ((1,0),(1,1)) x1 + (6,5) isPal_A(x1) = ((0,0),(1,0)) x1 + (2,1) mark_A(x1) = ((1,0),(1,1)) x1 + (7,14) active_A(x1) = ((1,0),(1,0)) x1 + (5,6) precedence: active# = __ = mark# > and = isList = isNeList = isNePal = isQid = isPal = mark = active partial status: pi(active#) = [] pi(__) = [] pi(mark#) = [] pi(and) = [] pi(isList) = [] pi(isNeList) = [] pi(isNePal) = [] pi(isQid) = [1] pi(isPal) = [] pi(mark) = [1] pi(active) = [] 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#(__(X1,X2)) -> mark#(X2) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isList(X)) -> active#(isList(X)) p4: active#(isList(V)) -> mark#(isNeList(V)) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(isNePal(X)) -> active#(isNePal(X)) p8: active#(isNeList(V)) -> mark#(isQid(V)) p9: mark#(isPal(X)) -> active#(isPal(X)) p10: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p11: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p12: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: mark#(__(X1,X2)) -> mark#(X2) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p8: mark#(isList(X)) -> active#(isList(X)) p9: active#(isNeList(V)) -> mark#(isQid(V)) p10: mark#(and(X1,X2)) -> mark#(X1) p11: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p12: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((1,0),(0,0)) x1 + (15,18) ___A(x1,x2) = ((1,0),(1,0)) x1 + ((1,0),(1,0)) x2 + (14,17) isPal_A(x1) = ((0,0),(1,0)) x1 + (18,30) active#_A(x1) = (17,18) isNePal_A(x1) = ((0,0),(1,0)) x1 + (2,1) and_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (0,7) isQid_A(x1) = ((0,0),(1,0)) x1 + (1,1) isNeList_A(x1) = ((0,0),(1,0)) x1 + (2,3) isList_A(x1) = ((0,0),(1,0)) x1 + (2,5) mark_A(x1) = ((1,0),(1,1)) x1 + (3,6) active_A(x1) = ((1,0),(1,1)) x1 + (19,0) precedence: mark# = __ = isPal = active# = isNePal = and = isNeList = isList = mark > isQid = active partial status: pi(mark#) = [] pi(__) = [] pi(isPal) = [] pi(active#) = [] pi(isNePal) = [] pi(and) = [1] pi(isQid) = [] pi(isNeList) = [] pi(isList) = [] pi(mark) = [1] pi(active) = [1] 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: mark#(__(X1,X2)) -> mark#(X2) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p8: mark#(isList(X)) -> active#(isList(X)) p9: mark#(and(X1,X2)) -> mark#(X1) p10: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p11: active#(isList(V)) -> mark#(isNeList(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: mark#(__(X1,X2)) -> mark#(X2) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isList(X)) -> active#(isList(X)) p4: active#(isList(V)) -> mark#(isNeList(V)) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(isNePal(X)) -> active#(isNePal(X)) p8: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p9: mark#(isPal(X)) -> active#(isPal(X)) p10: active#(isNePal(__(I,__(P,I)))) -> mark#(and(isQid(I),isPal(P))) p11: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((1,0),(0,0)) x1 + (0,3) ___A(x1,x2) = ((1,0),(0,0)) x2 + (4,0) and_A(x1,x2) = x1 + (0,2) isList_A(x1) = (2,5) active#_A(x1) = ((0,0),(1,0)) x1 + (2,1) isNeList_A(x1) = (2,4) isNePal_A(x1) = ((0,0),(1,0)) x1 + (2,5) isPal_A(x1) = ((0,0),(1,0)) x1 + (3,14) isQid_A(x1) = (1,0) mark_A(x1) = ((1,0),(1,0)) x1 + (4,15) active_A(x1) = ((1,0),(1,1)) x1 + (4,15) precedence: mark# = __ = and = isList = active# = isNeList = isNePal = isPal = isQid = mark = active partial status: pi(mark#) = [] pi(__) = [] pi(and) = [] pi(isList) = [] pi(active#) = [] pi(isNeList) = [] pi(isNePal) = [] pi(isPal) = [] pi(isQid) = [] pi(mark) = [] pi(active) = [] 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: mark#(__(X1,X2)) -> mark#(X2) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isList(X)) -> active#(isList(X)) p4: active#(isList(V)) -> mark#(isNeList(V)) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(isNePal(X)) -> active#(isNePal(X)) p8: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p9: mark#(isPal(X)) -> active#(isPal(X)) p10: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: mark#(__(X1,X2)) -> mark#(X2) p2: mark#(isPal(X)) -> active#(isPal(X)) p3: active#(isPal(V)) -> mark#(isNePal(V)) p4: mark#(isNePal(X)) -> active#(isNePal(X)) p5: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p8: mark#(isList(X)) -> active#(isList(X)) p9: active#(isList(V)) -> mark#(isNeList(V)) p10: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((0,0),(1,0)) x1 + (7,3) ___A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (25,28) isPal_A(x1) = ((1,0),(1,1)) x1 + (9,8) active#_A(x1) = ((0,0),(1,0)) x1 + (7,1) isNePal_A(x1) = (6,6) isNeList_A(x1) = ((1,0),(0,0)) x1 + (1,0) and_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (8,4) isList_A(x1) = ((1,0),(1,1)) x1 + (8,10) mark_A(x1) = ((1,0),(1,1)) x1 + (2,5) active_A(x1) = ((1,0),(1,1)) x1 + (10,11) precedence: isPal > __ > isNePal = isNeList = and = isList = mark = active > mark# = active# partial status: pi(mark#) = [] pi(__) = [2] pi(isPal) = [1] pi(active#) = [] pi(isNePal) = [] pi(isNeList) = [] pi(and) = [] pi(isList) = [] 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: mark#(isPal(X)) -> active#(isPal(X)) p2: active#(isPal(V)) -> mark#(isNePal(V)) p3: mark#(isNePal(X)) -> active#(isNePal(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(isList(X)) -> active#(isList(X)) p8: active#(isList(V)) -> mark#(isNeList(V)) p9: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: mark#(isPal(X)) -> active#(isPal(X)) p2: active#(isList(V)) -> mark#(isNeList(V)) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isList(X)) -> active#(isList(X)) p5: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p6: mark#(isNeList(X)) -> active#(isNeList(X)) p7: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p8: mark#(isNePal(X)) -> active#(isNePal(X)) p9: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = x1 + (3,1) isPal_A(x1) = ((1,0),(1,1)) x1 + (4,5) active#_A(x1) = ((1,0),(1,0)) x1 isList_A(x1) = ((1,0),(1,0)) x1 + (9,10) isNeList_A(x1) = ((1,0),(1,0)) x1 + (5,5) and_A(x1,x2) = x1 + (11,12) ___A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (19,0) isNePal_A(x1) = ((0,0),(1,0)) x1 + (1,2) mark_A(x1) = ((1,0),(1,0)) x1 + (10,11) active_A(x1) = ((1,0),(1,1)) x1 + (10,11) precedence: and > __ > isNePal > active# > mark# = isNeList = mark = active > isPal = isList partial status: pi(mark#) = [1] pi(isPal) = [] pi(active#) = [] pi(isList) = [] pi(isNeList) = [] pi(and) = [] pi(__) = [1] pi(isNePal) = [] pi(mark) = [] 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: mark#(isPal(X)) -> active#(isPal(X)) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isList(X)) -> active#(isList(X)) p4: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p7: mark#(isNePal(X)) -> active#(isNePal(X)) p8: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: mark#(isPal(X)) -> active#(isPal(X)) p2: active#(isPal(V)) -> mark#(isNePal(V)) p3: mark#(isNePal(X)) -> active#(isNePal(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(isList(X)) -> active#(isList(X)) p8: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((1,0),(1,0)) x1 isPal_A(x1) = ((1,0),(1,1)) x1 + (4,1) active#_A(x1) = ((1,0),(0,0)) x1 + (0,3) isNePal_A(x1) = (3,2) isNeList_A(x1) = ((1,0),(1,1)) x1 + (5,4) ___A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (13,0) and_A(x1,x2) = ((1,0),(0,0)) x1 + (5,10) isList_A(x1) = ((1,0),(1,0)) x1 + (7,8) mark_A(x1) = ((1,0),(1,1)) x1 + (6,9) active_A(x1) = ((1,0),(1,1)) x1 + (8,9) precedence: isList > mark# = isPal = active# > isNePal = isNeList = __ = and = mark = active partial status: pi(mark#) = [] pi(isPal) = [1] pi(active#) = [] pi(isNePal) = [] pi(isNeList) = [1] pi(__) = [2] pi(and) = [] pi(isList) = [] pi(mark) = [1] pi(active) = [1] The next rules are strictly ordered: p7 We remove them from the problem. -- SCC decomposition. Consider the dependency pair problem (P, R), where P consists of p1: mark#(isPal(X)) -> active#(isPal(X)) p2: active#(isPal(V)) -> mark#(isNePal(V)) p3: mark#(isNePal(X)) -> active#(isNePal(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p7: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(isPal(X)) -> active#(isPal(X)) p2: active#(isList(__(V1,V2))) -> mark#(and(isList(V1),isList(V2))) p3: mark#(and(X1,X2)) -> mark#(X1) p4: mark#(isNeList(X)) -> active#(isNeList(X)) p5: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p6: mark#(isNePal(X)) -> active#(isNePal(X)) p7: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((0,0),(1,0)) x1 + (3,1) isPal_A(x1) = ((1,0),(1,1)) x1 + (0,2) active#_A(x1) = ((0,0),(1,0)) x1 + (3,1) isList_A(x1) = ((1,0),(1,1)) x1 + (2,9) ___A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (5,23) and_A(x1,x2) = ((1,0),(1,1)) x1 + (4,11) isNeList_A(x1) = ((1,0),(1,1)) x1 + (2,9) isNePal_A(x1) = (0,1) mark_A(x1) = ((1,0),(1,1)) x1 active_A(x1) = ((1,0),(1,1)) x1 + (3,10) precedence: isPal > mark# = active# = __ = and = isNeList > isList = isNePal = mark = active partial status: pi(mark#) = [] pi(isPal) = [] pi(active#) = [] pi(isList) = [] pi(__) = [2] pi(and) = [] pi(isNeList) = [] pi(isNePal) = [] 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: mark#(isPal(X)) -> active#(isPal(X)) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isNeList(X)) -> active#(isNeList(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNePal(X)) -> active#(isNePal(X)) p6: active#(isPal(V)) -> mark#(isNePal(V)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(isPal(X)) -> active#(isPal(X)) p2: active#(isPal(V)) -> mark#(isNePal(V)) p3: mark#(isNePal(X)) -> active#(isNePal(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNeList(X)) -> active#(isNeList(X)) p6: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49, r50, r51 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((1,0),(1,0)) x1 + (1,1) isPal_A(x1) = ((1,0),(1,0)) x1 + (4,2) active#_A(x1) = ((1,0),(1,1)) x1 isNePal_A(x1) = ((1,0),(1,1)) x1 + (2,7) isNeList_A(x1) = ((1,0),(1,1)) x1 + (11,10) ___A(x1,x2) = (10,1) and_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (6,2) isList_A(x1) = (13,43) mark_A(x1) = ((1,0),(1,1)) x1 + (5,0) active_A(x1) = ((1,0),(1,0)) x1 + (12,0) precedence: isPal = isNePal = __ > mark# > active# = isNeList = and = isList = mark = active partial status: pi(mark#) = [] pi(isPal) = [] pi(active#) = [1] pi(isNePal) = [1] pi(isNeList) = [] pi(__) = [] pi(and) = [1] pi(isList) = [] pi(mark) = [1] pi(active) = [] 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: active#(isPal(V)) -> mark#(isNePal(V)) p2: mark#(isNePal(X)) -> active#(isNePal(X)) p3: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p4: mark#(isNeList(X)) -> active#(isNeList(X)) p5: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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: active#(isPal(V)) -> mark#(isNePal(V)) p2: mark#(and(X1,X2)) -> mark#(X1) p3: mark#(isNeList(X)) -> active#(isNeList(X)) p4: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p5: mark#(isNePal(X)) -> active#(isNePal(X)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: active#_A(x1) = x1 + (1,1) isPal_A(x1) = ((0,0),(1,0)) x1 + (3,4) mark#_A(x1) = x1 + (1,2) isNePal_A(x1) = ((0,0),(1,0)) x1 + (1,1) and_A(x1,x2) = ((1,0),(1,1)) x1 + ((0,0),(1,0)) x2 + (3,13) isNeList_A(x1) = ((1,0),(1,1)) x1 + (5,11) ___A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (4,10) isList_A(x1) = ((0,0),(1,0)) x1 + (3,1) mark_A(x1) = ((1,0),(1,1)) x1 + (2,0) active_A(x1) = ((1,0),(1,1)) x1 + (6,12) precedence: isPal > mark# > active# = isNePal = and = isNeList = __ = isList = mark = active partial status: pi(active#) = [1] pi(isPal) = [] pi(mark#) = [] pi(isNePal) = [] pi(and) = [1] pi(isNeList) = [1] pi(__) = [] pi(isList) = [] 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: mark#(and(X1,X2)) -> mark#(X1) p2: mark#(isNeList(X)) -> active#(isNeList(X)) p3: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p4: mark#(isNePal(X)) -> active#(isNePal(X)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(and(X1,X2)) -> mark#(X1) p2: mark#(isNePal(X)) -> active#(isNePal(X)) p3: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p4: mark#(isNeList(X)) -> active#(isNeList(X)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45, r48, r49 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = x1 + (3,9) and_A(x1,x2) = ((1,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (2,1) isNePal_A(x1) = x1 + (5,1) active#_A(x1) = (8,10) isNeList_A(x1) = (7,8) ___A(x1,x2) = ((0,0),(1,0)) x2 + (2,0) isList_A(x1) = ((0,0),(1,0)) x1 + (1,11) mark_A(x1) = ((1,0),(1,1)) x1 + (1,12) active_A(x1) = ((1,0),(1,1)) x1 + (8,9) precedence: mark# = and > isNePal = __ = mark > active# > isNeList = isList > active partial status: pi(mark#) = [] pi(and) = [] pi(isNePal) = [1] pi(active#) = [] pi(isNeList) = [] pi(__) = [] pi(isList) = [] pi(mark) = [1] pi(active) = [] 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#(and(X1,X2)) -> mark#(X1) p2: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) p3: mark#(isNeList(X)) -> active#(isNeList(X)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(and(X1,X2)) -> mark#(X1) p2: mark#(isNeList(X)) -> active#(isNeList(X)) p3: active#(isNeList(__(V1,V2))) -> mark#(and(isList(V1),isNeList(V2))) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of r38, r39, r40, r41, r42, r43, r44, r45 Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = x1 + (2,4) and_A(x1,x2) = ((1,0),(1,1)) x1 + (4,3) isNeList_A(x1) = ((1,0),(1,1)) x1 active#_A(x1) = ((1,0),(1,0)) x1 + (1,3) ___A(x1,x2) = ((0,0),(1,0)) x1 + (9,5) isList_A(x1) = (2,1) mark_A(x1) = ((1,0),(1,1)) x1 + (3,2) active_A(x1) = x1 + (1,4) precedence: mark# = and = isNeList = active# = __ > isList = mark = active partial status: pi(mark#) = [] pi(and) = [1] pi(isNeList) = [1] pi(active#) = [] pi(__) = [] pi(isList) = [] 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: mark#(and(X1,X2)) -> mark#(X1) p2: mark#(isNeList(X)) -> active#(isNeList(X)) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: mark#(and(X1,X2)) -> mark#(X1) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: mark#_A(x1) = ((1,0),(1,1)) x1 and_A(x1,x2) = ((1,0),(1,1)) x1 + x2 + (1,1) precedence: mark# = and partial status: pi(mark#) = [1] pi(and) = [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: __#(mark(X1),X2) -> __#(X1,X2) p2: __#(X1,active(X2)) -> __#(X1,X2) p3: __#(active(X1),X2) -> __#(X1,X2) p4: __#(X1,mark(X2)) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: __#_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (1,2) mark_A(x1) = ((1,0),(0,0)) x1 + (2,3) active_A(x1) = ((1,0),(0,0)) x1 + (2,1) precedence: __# = mark > active partial status: pi(__#) = [] pi(mark) = [] pi(active) = [] 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(X1),X2) -> __#(X1,X2) p2: __#(active(X1),X2) -> __#(X1,X2) p3: __#(X1,mark(X2)) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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(X1),X2) -> __#(X1,X2) p2: __#(X1,mark(X2)) -> __#(X1,X2) p3: __#(active(X1),X2) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: __#_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (1,2) mark_A(x1) = ((1,0),(0,0)) x1 + (2,1) active_A(x1) = ((1,0),(0,0)) x1 + (2,1) precedence: __# = mark = active partial status: pi(__#) = [] pi(mark) = [] pi(active) = [] 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(X1),X2) -> __#(X1,X2) p2: __#(active(X1),X2) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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(X1),X2) -> __#(X1,X2) p2: __#(active(X1),X2) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: __#_A(x1,x2) = x1 mark_A(x1) = ((1,0),(1,0)) x1 + (1,1) active_A(x1) = x1 + (1,1) precedence: mark > __# > active partial status: pi(__#) = [1] pi(mark) = [] 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: __#(mark(X1),X2) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: __#(mark(X1),X2) -> __#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: __#_A(x1,x2) = x1 mark_A(x1) = x1 + (1,1) precedence: __# = mark partial status: pi(__#) = [] 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: isNeList#(mark(X)) -> isNeList#(X) p2: isNeList#(active(X)) -> isNeList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isNeList#_A(x1) = ((1,0),(0,0)) x1 + (1,1) mark_A(x1) = x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (2,2) precedence: isNeList# = mark = active partial status: pi(isNeList#) = [] pi(mark) = [1] pi(active) = [] 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: isNeList#(active(X)) -> isNeList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNeList#(active(X)) -> isNeList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isNeList#_A(x1) = ((1,0),(1,0)) x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: isNeList# = active partial status: pi(isNeList#) = [] 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: 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(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: and#_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (1,2) mark_A(x1) = ((1,0),(0,0)) x1 + (2,3) active_A(x1) = ((1,0),(0,0)) x1 + (2,1) precedence: and# = mark > active partial status: pi(and#) = [] pi(mark) = [] pi(active) = [] 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(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: and#_A(x1,x2) = ((0,0),(1,0)) x1 + ((0,0),(1,0)) x2 + (2,2) mark_A(x1) = ((1,0),(0,0)) x1 + (3,1) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: and# = mark = active partial status: pi(and#) = [] pi(mark) = [] pi(active) = [] 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) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) 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#(mark(X1),X2) -> and#(X1,X2) p2: and#(active(X1),X2) -> and#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: and#_A(x1,x2) = x1 mark_A(x1) = ((1,0),(1,0)) x1 + (1,1) active_A(x1) = x1 + (1,1) precedence: mark > and# > active partial status: pi(and#) = [1] pi(mark) = [] 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) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: and#(mark(X1),X2) -> and#(X1,X2) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: and#_A(x1,x2) = x1 mark_A(x1) = x1 + (1,1) precedence: and# = mark partial status: pi(and#) = [] 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: isList#(mark(X)) -> isList#(X) p2: isList#(active(X)) -> isList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isList#_A(x1) = ((1,0),(0,0)) x1 + (1,1) mark_A(x1) = x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (2,2) precedence: isList# = mark = active partial status: pi(isList#) = [] pi(mark) = [1] pi(active) = [] 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: isList#(active(X)) -> isList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isList#(active(X)) -> isList#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isList#_A(x1) = ((1,0),(1,0)) x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: isList# = active partial status: pi(isList#) = [] 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: isQid#(mark(X)) -> isQid#(X) p2: isQid#(active(X)) -> isQid#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isQid#_A(x1) = ((1,0),(0,0)) x1 + (1,1) mark_A(x1) = x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (2,2) precedence: isQid# = mark = active partial status: pi(isQid#) = [] pi(mark) = [1] pi(active) = [] 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: isQid#(active(X)) -> isQid#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isQid#(active(X)) -> isQid#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isQid#_A(x1) = ((1,0),(1,0)) x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: isQid# = active partial status: pi(isQid#) = [] 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: isPal#(mark(X)) -> isPal#(X) p2: isPal#(active(X)) -> isPal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isPal#_A(x1) = ((1,0),(0,0)) x1 + (1,1) mark_A(x1) = x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (2,2) precedence: isPal# = mark = active partial status: pi(isPal#) = [] pi(mark) = [1] pi(active) = [] 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: isPal#(active(X)) -> isPal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isPal#(active(X)) -> isPal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isPal#_A(x1) = ((1,0),(1,0)) x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: isPal# = active partial status: pi(isPal#) = [] 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: isNePal#(mark(X)) -> isNePal#(X) p2: isNePal#(active(X)) -> isNePal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isNePal#_A(x1) = ((1,0),(0,0)) x1 + (1,1) mark_A(x1) = x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (2,2) precedence: isNePal# = mark = active partial status: pi(isNePal#) = [] pi(mark) = [1] pi(active) = [] 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: isNePal#(active(X)) -> isNePal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The estimated dependency graph contains the following SCCs: {p1} -- Reduction pair. Consider the dependency pair problem (P, R), where P consists of p1: isNePal#(active(X)) -> isNePal#(X) and R consists of: r1: active(__(__(X,Y),Z)) -> mark(__(X,__(Y,Z))) r2: active(__(X,nil())) -> mark(X) r3: active(__(nil(),X)) -> mark(X) r4: active(and(tt(),X)) -> mark(X) r5: active(isList(V)) -> mark(isNeList(V)) r6: active(isList(nil())) -> mark(tt()) r7: active(isList(__(V1,V2))) -> mark(and(isList(V1),isList(V2))) r8: active(isNeList(V)) -> mark(isQid(V)) r9: active(isNeList(__(V1,V2))) -> mark(and(isList(V1),isNeList(V2))) r10: active(isNeList(__(V1,V2))) -> mark(and(isNeList(V1),isList(V2))) r11: active(isNePal(V)) -> mark(isQid(V)) r12: active(isNePal(__(I,__(P,I)))) -> mark(and(isQid(I),isPal(P))) r13: active(isPal(V)) -> mark(isNePal(V)) r14: active(isPal(nil())) -> mark(tt()) r15: active(isQid(a())) -> mark(tt()) r16: active(isQid(e())) -> mark(tt()) r17: active(isQid(i())) -> mark(tt()) r18: active(isQid(o())) -> mark(tt()) r19: active(isQid(u())) -> mark(tt()) r20: mark(__(X1,X2)) -> active(__(mark(X1),mark(X2))) r21: mark(nil()) -> active(nil()) r22: mark(and(X1,X2)) -> active(and(mark(X1),X2)) r23: mark(tt()) -> active(tt()) r24: mark(isList(X)) -> active(isList(X)) r25: mark(isNeList(X)) -> active(isNeList(X)) r26: mark(isQid(X)) -> active(isQid(X)) r27: mark(isNePal(X)) -> active(isNePal(X)) r28: mark(isPal(X)) -> active(isPal(X)) r29: mark(a()) -> active(a()) r30: mark(e()) -> active(e()) r31: mark(i()) -> active(i()) r32: mark(o()) -> active(o()) r33: mark(u()) -> active(u()) r34: __(mark(X1),X2) -> __(X1,X2) r35: __(X1,mark(X2)) -> __(X1,X2) r36: __(active(X1),X2) -> __(X1,X2) r37: __(X1,active(X2)) -> __(X1,X2) r38: and(mark(X1),X2) -> and(X1,X2) r39: and(X1,mark(X2)) -> and(X1,X2) r40: and(active(X1),X2) -> and(X1,X2) r41: and(X1,active(X2)) -> and(X1,X2) r42: isList(mark(X)) -> isList(X) r43: isList(active(X)) -> isList(X) r44: isNeList(mark(X)) -> isNeList(X) r45: isNeList(active(X)) -> isNeList(X) r46: isQid(mark(X)) -> isQid(X) r47: isQid(active(X)) -> isQid(X) r48: isNePal(mark(X)) -> isNePal(X) r49: isNePal(active(X)) -> isNePal(X) r50: isPal(mark(X)) -> isPal(X) r51: isPal(active(X)) -> isPal(X) The set of usable rules consists of (no rules) Take the reduction pair: weighted path order base order: matrix interpretations: carrier: N^2 order: lexicographic order interpretations: isNePal#_A(x1) = ((1,0),(1,0)) x1 + (2,2) active_A(x1) = ((1,0),(0,0)) x1 + (1,1) precedence: isNePal# = active partial status: pi(isNePal#) = [] pi(active) = [] The next rules are strictly ordered: p1 We remove them from the problem. Then no dependency pair remains.