/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files -------------------------------------------------------------------------------- YES We split firstr-order part and higher-order part, and do modular checking by a general modularity. ******** FO SN check ******** Check SN using NaTT (Nagoya Termination Tool) Input TRS: 1: axxu11(tt(),X,Y,U) -> axxu12(axxsplitAt(mark(X),mark(U)),Y) 2: axxu12(pair(V,W),P) -> pair(cons(mark(P),V),mark(W)) 3: axxafterNth(X1,Y1) -> axxsnd(axxsplitAt(mark(X1),mark(Y1))) 4: axxand(tt(),U1) -> mark(U1) 5: axxfst(pair(V1,W1)) -> mark(V1) 6: axxhead(cons(P1,X2)) -> mark(P1) 7: axxnatsFrom(Y2) -> cons(mark(Y2),natsFrom(s(Y2))) 8: axxsel(U2,V2) -> axxhead(axxafterNth(mark(U2),mark(V2))) 9: axxsnd(pair(W2,P2)) -> mark(P2) 10: axxsplitAt(0(),X3) -> pair(nil(),mark(X3)) 11: axxsplitAt(s(Y3),cons(U3,V3)) -> axxu11(tt(),Y3,U3,V3) 12: axxtail(cons(W3,P3)) -> mark(P3) 13: axxtake(X4,Y4) -> axxfst(axxsplitAt(mark(X4),mark(Y4))) 14: mark(u11(U4,V4,W4,P4)) -> axxu11(mark(U4),V4,W4,P4) 15: mark(u12(X5,Y5)) -> axxu12(mark(X5),Y5) 16: mark(splitAt(U5,V5)) -> axxsplitAt(mark(U5),mark(V5)) 17: mark(afterNth(W5,P5)) -> axxafterNth(mark(W5),mark(P5)) 18: mark(snd(X6)) -> axxsnd(mark(X6)) 19: mark(and(Y6,U6)) -> axxand(mark(Y6),U6) 20: mark(fst(V6)) -> axxfst(mark(V6)) 21: mark(head(W6)) -> axxhead(mark(W6)) 22: mark(natsFrom(P6)) -> axxnatsFrom(mark(P6)) 23: mark(sel(X7,Y7)) -> axxsel(mark(X7),mark(Y7)) 24: mark(tail(U7)) -> axxtail(mark(U7)) 25: mark(take(V7,W7)) -> axxtake(mark(V7),mark(W7)) 26: mark(tt()) -> tt() 27: mark(pair(P7,X8)) -> pair(mark(P7),mark(X8)) 28: mark(cons(Y8,U8)) -> cons(mark(Y8),U8) 29: mark(s(V8)) -> s(mark(V8)) 30: mark(0()) -> 0() 31: mark(nil()) -> nil() 32: axxu11(W8,P8,X9,Y9) -> u11(W8,P8,X9,Y9) 33: axxu12(U9,V9) -> u12(U9,V9) 34: axxsplitAt(W9,P9) -> splitAt(W9,P9) 35: axxafterNth(X10,Y10) -> afterNth(X10,Y10) 36: axxsnd(U10) -> snd(U10) 37: axxand(V10,W10) -> and(V10,W10) 38: axxfst(P10) -> fst(P10) 39: axxhead(X11) -> head(X11) 40: axxnatsFrom(Y11) -> natsFrom(Y11) 41: axxsel(U11,V11) -> sel(U11,V11) 42: axxtail(W11) -> tail(W11) 43: axxtake(P11,X12) -> take(P11,X12) 44: _(X1,X2) -> X1 45: _(X1,X2) -> X2 Number of strict rules: 45 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #axxu12(pair(V,W),P) -> #mark(P) #2: #axxu12(pair(V,W),P) -> #mark(W) #3: #mark(s(V8)) -> #mark(V8) #4: #axxhead(cons(P1,X2)) -> #mark(P1) #5: #axxtake(X4,Y4) -> #axxfst(axxsplitAt(mark(X4),mark(Y4))) #6: #axxtake(X4,Y4) -> #axxsplitAt(mark(X4),mark(Y4)) #7: #axxtake(X4,Y4) -> #mark(X4) #8: #axxtake(X4,Y4) -> #mark(Y4) #9: #axxsnd(pair(W2,P2)) -> #mark(P2) #10: #axxsplitAt(s(Y3),cons(U3,V3)) -> #axxu11(tt(),Y3,U3,V3) #11: #mark(tail(U7)) -> #axxtail(mark(U7)) #12: #mark(tail(U7)) -> #mark(U7) #13: #mark(sel(X7,Y7)) -> #axxsel(mark(X7),mark(Y7)) #14: #mark(sel(X7,Y7)) -> #mark(X7) #15: #mark(sel(X7,Y7)) -> #mark(Y7) #16: #axxtail(cons(W3,P3)) -> #mark(P3) #17: #mark(u11(U4,V4,W4,P4)) -> #axxu11(mark(U4),V4,W4,P4) #18: #mark(u11(U4,V4,W4,P4)) -> #mark(U4) #19: #mark(take(V7,W7)) -> #axxtake(mark(V7),mark(W7)) #20: #mark(take(V7,W7)) -> #mark(V7) #21: #mark(take(V7,W7)) -> #mark(W7) #22: #mark(fst(V6)) -> #axxfst(mark(V6)) #23: #mark(fst(V6)) -> #mark(V6) #24: #axxnatsFrom(Y2) -> #mark(Y2) #25: #axxsplitAt(0(),X3) -> #mark(X3) #26: #axxfst(pair(V1,W1)) -> #mark(V1) #27: #mark(cons(Y8,U8)) -> #mark(Y8) #28: #mark(natsFrom(P6)) -> #axxnatsFrom(mark(P6)) #29: #mark(natsFrom(P6)) -> #mark(P6) #30: #mark(pair(P7,X8)) -> #mark(P7) #31: #mark(pair(P7,X8)) -> #mark(X8) #32: #mark(afterNth(W5,P5)) -> #axxafterNth(mark(W5),mark(P5)) #33: #mark(afterNth(W5,P5)) -> #mark(W5) #34: #mark(afterNth(W5,P5)) -> #mark(P5) #35: #mark(and(Y6,U6)) -> #axxand(mark(Y6),U6) #36: #mark(and(Y6,U6)) -> #mark(Y6) #37: #mark(head(W6)) -> #axxhead(mark(W6)) #38: #mark(head(W6)) -> #mark(W6) #39: #mark(splitAt(U5,V5)) -> #axxsplitAt(mark(U5),mark(V5)) #40: #mark(splitAt(U5,V5)) -> #mark(U5) #41: #mark(splitAt(U5,V5)) -> #mark(V5) #42: #axxafterNth(X1,Y1) -> #axxsnd(axxsplitAt(mark(X1),mark(Y1))) #43: #axxafterNth(X1,Y1) -> #axxsplitAt(mark(X1),mark(Y1)) #44: #axxafterNth(X1,Y1) -> #mark(X1) #45: #axxafterNth(X1,Y1) -> #mark(Y1) #46: #axxu11(tt(),X,Y,U) -> #axxu12(axxsplitAt(mark(X),mark(U)),Y) #47: #axxu11(tt(),X,Y,U) -> #axxsplitAt(mark(X),mark(U)) #48: #axxu11(tt(),X,Y,U) -> #mark(X) #49: #axxu11(tt(),X,Y,U) -> #mark(U) #50: #axxsel(U2,V2) -> #axxhead(axxafterNth(mark(U2),mark(V2))) #51: #axxsel(U2,V2) -> #axxafterNth(mark(U2),mark(V2)) #52: #axxsel(U2,V2) -> #mark(U2) #53: #axxsel(U2,V2) -> #mark(V2) #54: #mark(u12(X5,Y5)) -> #axxu12(mark(X5),Y5) #55: #mark(u12(X5,Y5)) -> #mark(X5) #56: #axxand(tt(),U1) -> #mark(U1) #57: #mark(snd(X6)) -> #axxsnd(mark(X6)) #58: #mark(snd(X6)) -> #mark(X6) Number of SCCs: 1, DPs: 58 SCC { #1..58 } POLO(Sum)... POLO(max)... succeeded. s w: x1 #axxu12 w: max(x1 + 9245, x2 + 9254) axxsnd w: x1 + 14641 axxu11 w: max(x1 + 14, x2 + 12, x3 + 13, x4 + 11) take w: max(x1 + 1183, x2 + 1182) and w: max(x1 + 10834, x2 + 10835) axxsplitAt w: max(x1 + 12, x2 + 11) pair w: max(x1 + 9, x2 + 10) fst w: x1 + 1171 axxand w: max(x1 + 10834, x2 + 10835) natsFrom w: x1 + 4139 splitAt w: max(x1 + 12, x2 + 11) #axxu11 w: max(x1 + 9262, x2 + 9258, x3 + 9263, x4 + 9259) _ w: 0 #axxsplitAt w: max(x1 + 9258, x2 + 9259) axxnatsFrom w: x1 + 4139 tail w: x1 + 978 #axxafterNth w: max(x1 + 14610, x2 + 11748) #mark w: x1 + 9253 #axxtail w: x1 + 9254 0 w: 7375 #axxnatsFrom w: x1 + 9254 u11 w: max(x1 + 14, x2 + 12, x3 + 13, x4 + 11) sel w: max(x1 + 22821, x2 + 17561) afterNth w: max(x1 + 15457, x2 + 14652) nil w: 3358 #axxsnd w: x1 + 9245 axxafterNth w: max(x1 + 15457, x2 + 14652) mark w: x1 u12 w: max(x1, x2 + 13) axxsel w: max(x1 + 22821, x2 + 17561) axxfst w: x1 + 1171 #_ w: 0 #axxand w: max(x2 + 12083) #axxsel w: max(x1 + 26671, x2 + 25147) head w: x1 + 2105 cons w: max(x1 + 4, x2) snd w: x1 + 14641 axxu12 w: max(x1, x2 + 13) axxtail w: x1 + 978 tt w: 1 axxtake w: max(x1 + 1183, x2 + 1182) #axxfst w: x1 + 9245 #axxtake w: max(x1 + 10116, x2 + 9312) #axxhead w: x1 + 9689 axxhead w: x1 + 2105 USABLE RULES: { 1..43 } Removed DPs: #1 #2 #4..9 #11..46 #48..54 #56..58 Number of SCCs: 2, DPs: 4 SCC { #3 #55 } POLO(Sum)... succeeded. s w: x1 + 1 #axxu12 w: 0 axxsnd w: 1 axxu11 w: x1 + x3 + x4 + 3 take w: x2 + 1 and w: 1 axxsplitAt w: 2 pair w: 3 fst w: 0 axxand w: x2 + 2 natsFrom w: x1 + 1 splitAt w: x1 + 3 #axxu11 w: 1 _ w: 0 #axxsplitAt w: 1 axxnatsFrom w: 0 tail w: 1 #axxafterNth w: 1 #mark w: x1 + 1 #axxtail w: 1 0 w: 2 #axxnatsFrom w: 1 u11 w: x2 + 4 sel w: 0 afterNth w: 2 nil w: 2 #axxsnd w: 1 axxafterNth w: x1 + x2 + 1 mark w: 1 u12 w: x1 + x2 + 2 axxsel w: 1 axxfst w: x1 #_ w: 0 #axxand w: 1 #axxsel w: 1 head w: 0 cons w: x1 + x2 + 868 snd w: x1 + 2 axxu12 w: x1 + 1 axxtail w: x1 tt w: 0 axxtake w: x1 #axxfst w: 1 #axxtake w: 1 #axxhead w: 0 axxhead w: 2 USABLE RULES: { } Removed DPs: #3 #55 Number of SCCs: 1, DPs: 2 SCC { #10 #47 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... succeeded. s s: [1] p: 4 w: x1 #axxu12 s: [2,1] p: 0 w: x1 + x2 axxsnd s: 1 axxu11 s: [2,3,4] p: 4 w: max(x1 + 3371, x2 + 6259, x3 + 1081, x4 + 9787) take s: [1,2] p: 5 w: x1 + x2 + 10186 and s: [] p: 0 w: x2 + 1 axxsplitAt s: [1] p: 4 w: max(x1 + 6259, x2 + 9787) pair s: [2] p: 2 w: max(x1, x2 + 1082) fst s: [] p: 0 w: x1 + 398 axxand s: [] p: 0 w: x2 + 1 natsFrom s: [] p: 2 w: x1 + 2731 splitAt s: [1] p: 4 w: max(x1 + 6259, x2 + 9787) #axxu11 s: [2] p: 5 w: max(x1 + 1, x2 + 6283) _ s: [] p: 0 w: 1 #axxsplitAt s: [1] p: 5 w: max(x1 + 6283) axxnatsFrom s: [] p: 2 w: x1 + 2731 tail s: [1] p: 0 w: x1 + 5942 #axxafterNth s: [] p: 0 w: x2 #mark s: [] p: 0 w: 1 #axxtail s: [] p: 0 w: 0 0 s: [] p: 1 w: 1082 #axxnatsFrom s: [] p: 0 w: 1 u11 s: [2,3,4] p: 4 w: max(x1 + 3371, x2 + 6259, x3 + 1081, x4 + 9787) sel s: [] p: 2 w: x1 + x2 + 20251 afterNth s: [2] p: 1 w: x1 + x2 + 12028 nil s: [] p: 4 w: 7341 #axxsnd s: [] p: 0 w: 1 axxafterNth s: [2] p: 1 w: x1 + x2 + 12028 mark s: 1 u12 s: [] p: 3 w: max(x1, x2 + 1081) axxsel s: [] p: 2 w: x1 + x2 + 20251 axxfst s: [] p: 0 w: x1 + 398 #_ s: [] p: 0 w: x1 #axxand s: [] p: 0 w: 1 #axxsel s: [] p: 0 w: 0 head s: [] p: 0 w: x1 + 8222 cons s: [1] p: 1 w: max(x1 + 1080, x2) snd s: 1 axxu12 s: [] p: 3 w: max(x1, x2 + 1081) axxtail s: [1] p: 0 w: x1 + 5942 tt s: [] p: 4 w: 6281 axxtake s: [1,2] p: 5 w: x1 + x2 + 10186 #axxfst s: [] p: 0 w: 1 #axxtake s: [] p: 0 w: x2 #axxhead s: [] p: 0 w: 0 axxhead s: [] p: 0 w: x1 + 8222 USABLE RULES: { 1..43 } Removed DPs: #10 Number of SCCs: 0, DPs: 0 ... Input TRS: 1: axxu11(tt(),X,Y,U) -> axxu12(axxsplitAt(mark(X),mark(U)),Y) 2: axxu12(pair(V,W),P) -> pair(cons(mark(P),V),mark(W)) 3: axxafterNth(X1,Y1) -> axxsnd(axxsplitAt(mark(X1),mark(Y1))) 4: axxand(tt(),U1) -> mark(U1) 5: axxfst(pair(V1,W1)) -> mark(V1) 6: axxhead(cons(P1,X2)) -> mark(P1) 7: axxnatsFrom(Y2) -> cons(mark(Y2),natsFrom(s(Y2))) 8: axxsel(U2,V2) -> axxhead(axxafterNth(mark(U2),mark(V2))) 9: axxsnd(pair(W2,P2)) -> mark(P2) 10: axxsplitAt(0(),X3) -> pair(nil(),mark(X3)) 11: axxsplitAt(s(Y3),cons(U3,V3)) -> axxu11(tt(),Y3,U3,V3) 12: axxtail(cons(W3,P3)) -> mark(P3) 13: axxtake(X4,Y4) -> axxfst(axxsplitAt(mark(X4),mark(Y4))) 14: mark(u11(U4,V4,W4,P4)) -> axxu11(mark(U4),V4,W4,P4) 15: mark(u12(X5,Y5)) -> axxu12(mark(X5),Y5) 16: mark(splitAt(U5,V5)) -> axxsplitAt(mark(U5),mark(V5)) 17: mark(afterNth(W5,P5)) -> axxafterNth(mark(W5),mark(P5)) 18: mark(snd(X6)) -> axxsnd(mark(X6)) 19: mark(and(Y6,U6)) -> axxand(mark(Y6),U6) 20: mark(fst(V6)) -> axxfst(mark(V6)) 21: mark(head(W6)) -> axxhead(mark(W6)) 22: mark(natsFrom(P6)) -> axxnatsFrom(mark(P6)) 23: mark(sel(X7,Y7)) -> axxsel(mark(X7),mark(Y7)) 24: mark(tail(U7)) -> axxtail(mark(U7)) 25: mark(take(V7,W7)) -> axxtake(mark(V7),mark(W7)) 26: mark(tt()) -> tt() 27: mark(pair(P7,X8)) -> pair(mark(P7),mark(X8)) 28: mark(cons(Y8,U8)) -> cons(mark(Y8),U8) 29: mark(s(V8)) -> s(mark(V8)) 30: mark(0()) -> 0() 31: mark(nil()) -> nil() 32: axxu11(W8,P8,X9,Y9) -> u11(W8,P8,X9,Y9) 33: axxu12(U9,V9) -> u12(U9,V9) 34: axxsplitAt(W9,P9) -> splitAt(W9,P9) 35: axxafterNth(X10,Y10) -> afterNth(X10,Y10) 36: axxsnd(U10) -> snd(U10) 37: axxand(V10,W10) -> and(V10,W10) 38: axxfst(P10) -> fst(P10) 39: axxhead(X11) -> head(X11) 40: axxnatsFrom(Y11) -> natsFrom(Y11) 41: axxsel(U11,V11) -> sel(U11,V11) 42: axxtail(W11) -> tail(W11) 43: axxtake(P11,X12) -> take(P11,X12) 44: _(X1,X2) -> X1 45: _(X1,X2) -> X2 Number of strict rules: 45 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #axxu12(pair(V,W),P) -> #mark(P) #2: #axxu12(pair(V,W),P) -> #mark(W) #3: #mark(s(V8)) -> #mark(V8) #4: #axxhead(cons(P1,X2)) -> #mark(P1) #5: #axxtake(X4,Y4) -> #axxfst(axxsplitAt(mark(X4),mark(Y4))) #6: #axxtake(X4,Y4) -> #axxsplitAt(mark(X4),mark(Y4)) #7: #axxtake(X4,Y4) -> #mark(X4) #8: #axxtake(X4,Y4) -> #mark(Y4) #9: #axxsnd(pair(W2,P2)) -> #mark(P2) #10: #axxsplitAt(s(Y3),cons(U3,V3)) -> #axxu11(tt(),Y3,U3,V3) #11: #mark(tail(U7)) -> #axxtail(mark(U7)) #12: #mark(tail(U7)) -> #mark(U7) #13: #mark(sel(X7,Y7)) -> #axxsel(mark(X7),mark(Y7)) #14: #mark(sel(X7,Y7)) -> #mark(X7) #15: #mark(sel(X7,Y7)) -> #mark(Y7) #16: #axxtail(cons(W3,P3)) -> #mark(P3) #17: #mark(u11(U4,V4,W4,P4)) -> #axxu11(mark(U4),V4,W4,P4) #18: #mark(u11(U4,V4,W4,P4)) -> #mark(U4) #19: #mark(take(V7,W7)) -> #axxtake(mark(V7),mark(W7)) #20: #mark(take(V7,W7)) -> #mark(V7) #21: #mark(take(V7,W7)) -> #mark(W7) #22: #mark(fst(V6)) -> #axxfst(mark(V6)) #23: #mark(fst(V6)) -> #mark(V6) #24: #axxnatsFrom(Y2) -> #mark(Y2) #25: #axxsplitAt(0(),X3) -> #mark(X3) #26: #axxfst(pair(V1,W1)) -> #mark(V1) #27: #mark(cons(Y8,U8)) -> #mark(Y8) #28: #mark(natsFrom(P6)) -> #axxnatsFrom(mark(P6)) #29: #mark(natsFrom(P6)) -> #mark(P6) #30: #mark(pair(P7,X8)) -> #mark(P7) #31: #mark(pair(P7,X8)) -> #mark(X8) #32: #mark(afterNth(W5,P5)) -> #axxafterNth(mark(W5),mark(P5)) #33: #mark(afterNth(W5,P5)) -> #mark(W5) #34: #mark(afterNth(W5,P5)) -> #mark(P5) #35: #mark(and(Y6,U6)) -> #axxand(mark(Y6),U6) #36: #mark(and(Y6,U6)) -> #mark(Y6) #37: #mark(head(W6)) -> #axxhead(mark(W6)) #38: #mark(head(W6)) -> #mark(W6) #39: #mark(splitAt(U5,V5)) -> #axxsplitAt(mark(U5),mark(V5)) #40: #mark(splitAt(U5,V5)) -> #mark(U5) #41: #mark(splitAt(U5,V5)) -> #mark(V5) #42: #axxafterNth(X1,Y1) -> #axxsnd(axxsplitAt(mark(X1),mark(Y1))) #43: #axxafterNth(X1,Y1) -> #axxsplitAt(mark(X1),mark(Y1)) #44: #axxafterNth(X1,Y1) -> #mark(X1) #45: #axxafterNth(X1,Y1) -> #mark(Y1) #46: #axxu11(tt(),X,Y,U) -> #axxu12(axxsplitAt(mark(X),mark(U)),Y) #47: #axxu11(tt(),X,Y,U) -> #axxsplitAt(mark(X),mark(U)) #48: #axxu11(tt(),X,Y,U) -> #mark(X) #49: #axxu11(tt(),X,Y,U) -> #mark(U) #50: #axxsel(U2,V2) -> #axxhead(axxafterNth(mark(U2),mark(V2))) #51: #axxsel(U2,V2) -> #axxafterNth(mark(U2),mark(V2)) #52: #axxsel(U2,V2) -> #mark(U2) #53: #axxsel(U2,V2) -> #mark(V2) #54: #mark(u12(X5,Y5)) -> #axxu12(mark(X5),Y5) #55: #mark(u12(X5,Y5)) -> #mark(X5) #56: #axxand(tt(),U1) -> #mark(U1) #57: #mark(snd(X6)) -> #axxsnd(mark(X6)) #58: #mark(snd(X6)) -> #mark(X6) Number of SCCs: 1, DPs: 58 SCC { #1..58 } POLO(Sum)... POLO(max)... succeeded. s w: x1 #axxu12 w: max(x1 + 9245, x2 + 9254) axxsnd w: x1 + 14641 axxu11 w: max(x1 + 14, x2 + 12, x3 + 13, x4 + 11) take w: max(x1 + 1183, x2 + 1182) and w: max(x1 + 10834, x2 + 10835) axxsplitAt w: max(x1 + 12, x2 + 11) pair w: max(x1 + 9, x2 + 10) fst w: x1 + 1171 axxand w: max(x1 + 10834, x2 + 10835) natsFrom w: x1 + 4139 splitAt w: max(x1 + 12, x2 + 11) #axxu11 w: max(x1 + 9262, x2 + 9258, x3 + 9263, x4 + 9259) _ w: 0 #axxsplitAt w: max(x1 + 9258, x2 + 9259) axxnatsFrom w: x1 + 4139 tail w: x1 + 978 #axxafterNth w: max(x1 + 14610, x2 + 11748) #mark w: x1 + 9253 #axxtail w: x1 + 9254 0 w: 7375 #axxnatsFrom w: x1 + 9254 u11 w: max(x1 + 14, x2 + 12, x3 + 13, x4 + 11) sel w: max(x1 + 22821, x2 + 17561) afterNth w: max(x1 + 15457, x2 + 14652) nil w: 3358 #axxsnd w: x1 + 9245 axxafterNth w: max(x1 + 15457, x2 + 14652) mark w: x1 u12 w: max(x1, x2 + 13) axxsel w: max(x1 + 22821, x2 + 17561) axxfst w: x1 + 1171 #_ w: 0 #axxand w: max(x2 + 12083) #axxsel w: max(x1 + 26671, x2 + 25147) head w: x1 + 2105 cons w: max(x1 + 4, x2) snd w: x1 + 14641 axxu12 w: max(x1, x2 + 13) axxtail w: x1 + 978 tt w: 1 axxtake w: max(x1 + 1183, x2 + 1182) #axxfst w: x1 + 9245 #axxtake w: max(x1 + 10116, x2 + 9312) #axxhead w: x1 + 9689 axxhead w: x1 + 2105 USABLE RULES: { 1..43 } Removed DPs: #1 #2 #4..9 #11..46 #48..54 #56..58 Number of SCCs: 2, DPs: 4 SCC { #3 #55 } POLO(Sum)... succeeded. s w: x1 + 1 #axxu12 w: 0 axxsnd w: 1 axxu11 w: x1 + x3 + x4 + 3 take w: x2 + 1 and w: 1 axxsplitAt w: 2 pair w: 3 fst w: 0 axxand w: x2 + 2 natsFrom w: x1 + 1 splitAt w: x1 + 3 #axxu11 w: 1 _ w: 0 #axxsplitAt w: 1 axxnatsFrom w: 0 tail w: 1 #axxafterNth w: 1 #mark w: x1 + 1 #axxtail w: 1 0 w: 2 #axxnatsFrom w: 1 u11 w: x2 + 4 sel w: 0 afterNth w: 2 nil w: 2 #axxsnd w: 1 axxafterNth w: x1 + x2 + 1 mark w: 1 u12 w: x1 + x2 + 2 axxsel w: 1 axxfst w: x1 #_ w: 0 #axxand w: 1 #axxsel w: 1 head w: 0 cons w: x1 + x2 + 868 snd w: x1 + 2 axxu12 w: x1 + 1 axxtail w: x1 tt w: 0 axxtake w: x1 #axxfst w: 1 #axxtake w: 1 #axxhead w: 0 axxhead w: 2 USABLE RULES: { } Removed DPs: #3 #55 Number of SCCs: 1, DPs: 2 SCC { #10 #47 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... succeeded. s s: [1] p: 4 w: x1 #axxu12 s: [2,1] p: 0 w: x1 + x2 axxsnd s: 1 axxu11 s: [2,3,4] p: 4 w: max(x1 + 3371, x2 + 6259, x3 + 1081, x4 + 9787) take s: [1,2] p: 5 w: x1 + x2 + 10186 and s: [] p: 0 w: x2 + 1 axxsplitAt s: [1] p: 4 w: max(x1 + 6259, x2 + 9787) pair s: [2] p: 2 w: max(x1, x2 + 1082) fst s: [] p: 0 w: x1 + 398 axxand s: [] p: 0 w: x2 + 1 natsFrom s: [] p: 2 w: x1 + 2731 splitAt s: [1] p: 4 w: max(x1 + 6259, x2 + 9787) #axxu11 s: [2] p: 5 w: max(x1 + 1, x2 + 6283) _ s: [] p: 0 w: 1 #axxsplitAt s: [1] p: 5 w: max(x1 + 6283) axxnatsFrom s: [] p: 2 w: x1 + 2731 tail s: [1] p: 0 w: x1 + 5942 #axxafterNth s: [] p: 0 w: x2 #mark s: [] p: 0 w: 1 #axxtail s: [] p: 0 w: 0 0 s: [] p: 1 w: 1082 #axxnatsFrom s: [] p: 0 w: 1 u11 s: [2,3,4] p: 4 w: max(x1 + 3371, x2 + 6259, x3 + 1081, x4 + 9787) sel s: [] p: 2 w: x1 + x2 + 20251 afterNth s: [2] p: 1 w: x1 + x2 + 12028 nil s: [] p: 4 w: 7341 #axxsnd s: [] p: 0 w: 1 axxafterNth s: [2] p: 1 w: x1 + x2 + 12028 mark s: 1 u12 s: [] p: 3 w: max(x1, x2 + 1081) axxsel s: [] p: 2 w: x1 + x2 + 20251 axxfst s: [] p: 0 w: x1 + 398 #_ s: [] p: 0 w: x1 #axxand s: [] p: 0 w: 1 #axxsel s: [] p: 0 w: 0 head s: [] p: 0 w: x1 + 8222 cons s: [1] p: 1 w: max(x1 + 1080, x2) snd s: 1 axxu12 s: [] p: 3 w: max(x1, x2 + 1081) axxtail s: [1] p: 0 w: x1 + 5942 tt s: [] p: 4 w: 6281 axxtake s: [1,2] p: 5 w: x1 + x2 + 10186 #axxfst s: [] p: 0 w: 1 #axxtake s: [] p: 0 w: x2 #axxhead s: [] p: 0 w: 0 axxhead s: [] p: 0 w: x1 + 8222 USABLE RULES: { 1..43 } Removed DPs: #10 Number of SCCs: 0, DPs: 0 >>YES ******** Signature ******** foldr : (((A,A) -> A),A,A) -> A nil : A cons : (A,A) -> A ******** Computation rules ******** (44) foldr(%Y.%X.Z12[%Y,%X],U12,nil) => U12 (45) foldr(%U.%Z.H12[%U,%Z],W12,cons(P12,X13)) => H12[P12,foldr(%W.%V.H12[%W,%V],W12,X13)] ******** General Schema criterion ******** Found constructors: 0, afterNth, and, cons, fst, head, natsFrom, nil, pair, s, sel, snd, splitAt, tail, take, tt, u11, u12 Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>Regared as equal: mark, axxtake Checking (1) axxu11(tt,X,Y,U) => axxu12(axxsplitAt(mark(X),mark(U)),Y) (fun axxu11>axxu12) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta X)[is acc in tt,X,Y,U] [is positive in tt] [is acc in X] (fun axxu11>mark) (meta U)[is acc in tt,X,Y,U] [is positive in tt] [is acc in U] (meta Y)[is acc in tt,X,Y,U] [is positive in tt] [is acc in Y] >>True Checking (2) axxu12(pair(V,W),P) => pair(cons(mark(P),V),mark(W)) (fun axxu12>pair) (fun axxu12>cons) (fun axxu12>mark) (meta P)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in P] (meta V)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in V] (fun axxu12>mark) (meta W)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in W] >>True Checking (3) axxafterNth(X1,Y1) => axxsnd(axxsplitAt(mark(X1),mark(Y1))) (fun axxafterNth>axxsnd) (fun axxafterNth>axxsplitAt) (fun axxafterNth>mark) (meta X1)[is acc in X1,Y1] [is acc in X1] (fun axxafterNth>mark) (meta Y1)[is acc in X1,Y1] [is acc in Y1] >>True Checking (4) axxand(tt,U1) => mark(U1) (fun axxand>mark) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (5) axxfst(pair(V1,W1)) => mark(V1) (fun axxfst>mark) (meta V1)[is acc in pair(V1,W1)] [is positive in pair(V1,W1)] [is acc in V1] >>True Checking (6) axxhead(cons(P1,X2)) => mark(P1) (fun axxhead>mark) (meta P1)[is acc in cons(P1,X2)] [is positive in cons(P1,X2)] [is acc in P1] >>True Checking (7) axxnatsFrom(Y2) => cons(mark(Y2),natsFrom(s(Y2))) (fun axxnatsFrom>cons) (fun axxnatsFrom>mark) (meta Y2)[is acc in Y2] [is acc in Y2] (fun axxnatsFrom>natsFrom) (fun axxnatsFrom>s) (meta Y2)[is acc in Y2] [is acc in Y2] >>True Checking (8) axxsel(U2,V2) => axxhead(axxafterNth(mark(U2),mark(V2))) (fun axxsel>axxhead) (fun axxsel>axxafterNth) (fun axxsel>mark) (meta U2)[is acc in U2,V2] [is acc in U2] (fun axxsel>mark) (meta V2)[is acc in U2,V2] [is acc in V2] >>True Checking (9) axxsnd(pair(W2,P2)) => mark(P2) (fun axxsnd>mark) (meta P2)[is acc in pair(W2,P2)] [is positive in pair(W2,P2)] [is acc in P2] >>True Checking (10) axxsplitAt(0,X3) => pair(nil,mark(X3)) (fun axxsplitAt>pair) (fun axxsplitAt>nil) (fun axxsplitAt>mark) (meta X3)[is acc in 0,X3] [is positive in 0] [is acc in X3] >>True Checking (11) axxsplitAt(s(Y3),cons(U3,V3)) => axxu11(tt,Y3,U3,V3) (fun axxsplitAt>axxu11) (fun axxsplitAt>tt) (meta Y3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is acc in Y3] (meta U3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in U3] (meta V3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in V3] >>True Checking (12) axxtail(cons(W3,P3)) => mark(P3) (fun axxtail>mark) (meta P3)[is acc in cons(W3,P3)] [is positive in cons(W3,P3)] [is acc in P3] >>True Checking (13) axxtake(X4,Y4) => axxfst(axxsplitAt(mark(X4),mark(Y4))) (fun axxtake>axxfst) (fun axxtake>axxsplitAt) (fun axxtake=mark) subterm comparison of args w. LR LR >>False Try again using status RL Checking (1) axxu11(tt,X,Y,U) => axxu12(axxsplitAt(mark(X),mark(U)),Y) (fun axxu11>axxu12) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta X)[is acc in tt,X,Y,U] [is positive in tt] [is acc in X] (fun axxu11>mark) (meta U)[is acc in tt,X,Y,U] [is positive in tt] [is acc in U] (meta Y)[is acc in tt,X,Y,U] [is positive in tt] [is acc in Y] >>True Checking (2) axxu12(pair(V,W),P) => pair(cons(mark(P),V),mark(W)) (fun axxu12>pair) (fun axxu12>cons) (fun axxu12>mark) (meta P)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in P] (meta V)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in V] (fun axxu12>mark) (meta W)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in W] >>True Checking (3) axxafterNth(X1,Y1) => axxsnd(axxsplitAt(mark(X1),mark(Y1))) (fun axxafterNth>axxsnd) (fun axxafterNth>axxsplitAt) (fun axxafterNth>mark) (meta X1)[is acc in X1,Y1] [is acc in X1] (fun axxafterNth>mark) (meta Y1)[is acc in X1,Y1] [is acc in Y1] >>True Checking (4) axxand(tt,U1) => mark(U1) (fun axxand>mark) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (5) axxfst(pair(V1,W1)) => mark(V1) (fun axxfst>mark) (meta V1)[is acc in pair(V1,W1)] [is positive in pair(V1,W1)] [is acc in V1] >>True Checking (6) axxhead(cons(P1,X2)) => mark(P1) (fun axxhead>mark) (meta P1)[is acc in cons(P1,X2)] [is positive in cons(P1,X2)] [is acc in P1] >>True Checking (7) axxnatsFrom(Y2) => cons(mark(Y2),natsFrom(s(Y2))) (fun axxnatsFrom>cons) (fun axxnatsFrom>mark) (meta Y2)[is acc in Y2] [is acc in Y2] (fun axxnatsFrom>natsFrom) (fun axxnatsFrom>s) (meta Y2)[is acc in Y2] [is acc in Y2] >>True Checking (8) axxsel(U2,V2) => axxhead(axxafterNth(mark(U2),mark(V2))) (fun axxsel>axxhead) (fun axxsel>axxafterNth) (fun axxsel>mark) (meta U2)[is acc in U2,V2] [is acc in U2] (fun axxsel>mark) (meta V2)[is acc in U2,V2] [is acc in V2] >>True Checking (9) axxsnd(pair(W2,P2)) => mark(P2) (fun axxsnd>mark) (meta P2)[is acc in pair(W2,P2)] [is positive in pair(W2,P2)] [is acc in P2] >>True Checking (10) axxsplitAt(0,X3) => pair(nil,mark(X3)) (fun axxsplitAt>pair) (fun axxsplitAt>nil) (fun axxsplitAt>mark) (meta X3)[is acc in 0,X3] [is positive in 0] [is acc in X3] >>True Checking (11) axxsplitAt(s(Y3),cons(U3,V3)) => axxu11(tt,Y3,U3,V3) (fun axxsplitAt>axxu11) (fun axxsplitAt>tt) (meta Y3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is acc in Y3] (meta U3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in U3] (meta V3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in V3] >>True Checking (12) axxtail(cons(W3,P3)) => mark(P3) (fun axxtail>mark) (meta P3)[is acc in cons(W3,P3)] [is positive in cons(W3,P3)] [is acc in P3] >>True Checking (13) axxtake(X4,Y4) => axxfst(axxsplitAt(mark(X4),mark(Y4))) (fun axxtake>axxfst) (fun axxtake>axxsplitAt) (fun axxtake=mark) subterm comparison of args w. RL RL >>False Try again using status Mul Checking (1) axxu11(tt,X,Y,U) => axxu12(axxsplitAt(mark(X),mark(U)),Y) (fun axxu11>axxu12) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta X)[is acc in tt,X,Y,U] [is positive in tt] [is acc in X] (fun axxu11>mark) (meta U)[is acc in tt,X,Y,U] [is positive in tt] [is acc in U] (meta Y)[is acc in tt,X,Y,U] [is positive in tt] [is acc in Y] >>True Checking (2) axxu12(pair(V,W),P) => pair(cons(mark(P),V),mark(W)) (fun axxu12>pair) (fun axxu12>cons) (fun axxu12>mark) (meta P)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in P] (meta V)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in V] (fun axxu12>mark) (meta W)[is acc in pair(V,W),P] [is positive in pair(V,W)] [is acc in W] >>True Checking (3) axxafterNth(X1,Y1) => axxsnd(axxsplitAt(mark(X1),mark(Y1))) (fun axxafterNth>axxsnd) (fun axxafterNth>axxsplitAt) (fun axxafterNth>mark) (meta X1)[is acc in X1,Y1] [is acc in X1] (fun axxafterNth>mark) (meta Y1)[is acc in X1,Y1] [is acc in Y1] >>True Checking (4) axxand(tt,U1) => mark(U1) (fun axxand>mark) (meta U1)[is acc in tt,U1] [is positive in tt] [is acc in U1] >>True Checking (5) axxfst(pair(V1,W1)) => mark(V1) (fun axxfst>mark) (meta V1)[is acc in pair(V1,W1)] [is positive in pair(V1,W1)] [is acc in V1] >>True Checking (6) axxhead(cons(P1,X2)) => mark(P1) (fun axxhead>mark) (meta P1)[is acc in cons(P1,X2)] [is positive in cons(P1,X2)] [is acc in P1] >>True Checking (7) axxnatsFrom(Y2) => cons(mark(Y2),natsFrom(s(Y2))) (fun axxnatsFrom>cons) (fun axxnatsFrom>mark) (meta Y2)[is acc in Y2] [is acc in Y2] (fun axxnatsFrom>natsFrom) (fun axxnatsFrom>s) (meta Y2)[is acc in Y2] [is acc in Y2] >>True Checking (8) axxsel(U2,V2) => axxhead(axxafterNth(mark(U2),mark(V2))) (fun axxsel>axxhead) (fun axxsel>axxafterNth) (fun axxsel>mark) (meta U2)[is acc in U2,V2] [is acc in U2] (fun axxsel>mark) (meta V2)[is acc in U2,V2] [is acc in V2] >>True Checking (9) axxsnd(pair(W2,P2)) => mark(P2) (fun axxsnd>mark) (meta P2)[is acc in pair(W2,P2)] [is positive in pair(W2,P2)] [is acc in P2] >>True Checking (10) axxsplitAt(0,X3) => pair(nil,mark(X3)) (fun axxsplitAt>pair) (fun axxsplitAt>nil) (fun axxsplitAt>mark) (meta X3)[is acc in 0,X3] [is positive in 0] [is acc in X3] >>True Checking (11) axxsplitAt(s(Y3),cons(U3,V3)) => axxu11(tt,Y3,U3,V3) (fun axxsplitAt>axxu11) (fun axxsplitAt>tt) (meta Y3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is acc in Y3] (meta U3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in U3] (meta V3)[is acc in s(Y3),cons(U3,V3)] [is positive in s(Y3)] [is positive in cons(U3,V3)] [is acc in V3] >>True Checking (12) axxtail(cons(W3,P3)) => mark(P3) (fun axxtail>mark) (meta P3)[is acc in cons(W3,P3)] [is positive in cons(W3,P3)] [is acc in P3] >>True Checking (13) axxtake(X4,Y4) => axxfst(axxsplitAt(mark(X4),mark(Y4))) (fun axxtake>axxfst) (fun axxtake>axxsplitAt) (fun axxtake=mark) subterm comparison of args w. Mul Mul (meta X4)[is acc in X4,Y4] [is acc in X4] (fun axxtake=mark) subterm comparison of args w. Mul Mul (meta Y4)[is acc in X4,Y4] [is acc in Y4] >>True Checking (14) mark(u11(U4,V4,W4,P4)) => axxu11(mark(U4),V4,W4,P4) (fun mark>axxu11) (fun mark=mark) subterm comparison of args w. Mul Mul (meta U4)[is acc in u11(U4,V4,W4,P4)] [is positive in u11(U4,V4,W4,P4)] [is acc in U4] (meta V4)[is acc in u11(U4,V4,W4,P4)] [is positive in u11(U4,V4,W4,P4)] [is acc in V4] (meta W4)[is acc in u11(U4,V4,W4,P4)] [is positive in u11(U4,V4,W4,P4)] [is acc in W4] (meta P4)[is acc in u11(U4,V4,W4,P4)] [is positive in u11(U4,V4,W4,P4)] [is acc in P4] >>True Checking (15) mark(u12(X5,Y5)) => axxu12(mark(X5),Y5) (fun mark>axxu12) (fun mark=mark) subterm comparison of args w. Mul Mul (meta X5)[is acc in u12(X5,Y5)] [is positive in u12(X5,Y5)] [is acc in X5] (meta Y5)[is acc in u12(X5,Y5)] [is positive in u12(X5,Y5)] [is acc in Y5] >>True Checking (16) mark(splitAt(U5,V5)) => axxsplitAt(mark(U5),mark(V5)) (fun mark>axxsplitAt) (fun mark=mark) subterm comparison of args w. Mul Mul (meta U5)[is acc in splitAt(U5,V5)] [is positive in splitAt(U5,V5)] [is acc in U5] (fun mark=mark) subterm comparison of args w. Mul Mul (meta V5)[is acc in splitAt(U5,V5)] [is positive in splitAt(U5,V5)] [is acc in V5] >>True Checking (17) mark(afterNth(W5,P5)) => axxafterNth(mark(W5),mark(P5)) (fun mark>axxafterNth) (fun mark=mark) subterm comparison of args w. Mul Mul (meta W5)[is acc in afterNth(W5,P5)] [is positive in afterNth(W5,P5)] [is acc in W5] (fun mark=mark) subterm comparison of args w. Mul Mul (meta P5)[is acc in afterNth(W5,P5)] [is positive in afterNth(W5,P5)] [is acc in P5] >>True Checking (18) mark(snd(X6)) => axxsnd(mark(X6)) (fun mark>axxsnd) (fun mark=mark) subterm comparison of args w. Mul Mul (meta X6)[is acc in snd(X6)] [is positive in snd(X6)] [is acc in X6] >>True Checking (19) mark(and(Y6,U6)) => axxand(mark(Y6),U6) (fun mark>axxand) (fun mark=mark) subterm comparison of args w. Mul Mul (meta Y6)[is acc in and(Y6,U6)] [is positive in and(Y6,U6)] [is acc in Y6] (meta U6)[is acc in and(Y6,U6)] [is positive in and(Y6,U6)] [is acc in U6] >>True Checking (20) mark(fst(V6)) => axxfst(mark(V6)) (fun mark>axxfst) (fun mark=mark) subterm comparison of args w. Mul Mul (meta V6)[is acc in fst(V6)] [is positive in fst(V6)] [is acc in V6] >>True Checking (21) mark(head(W6)) => axxhead(mark(W6)) (fun mark>axxhead) (fun mark=mark) subterm comparison of args w. Mul Mul (meta W6)[is acc in head(W6)] [is positive in head(W6)] [is acc in W6] >>True Checking (22) mark(natsFrom(P6)) => axxnatsFrom(mark(P6)) (fun mark>axxnatsFrom) (fun mark=mark) subterm comparison of args w. Mul Mul (meta P6)[is acc in natsFrom(P6)] [is positive in natsFrom(P6)] [is acc in P6] >>True Checking (23) mark(sel(X7,Y7)) => axxsel(mark(X7),mark(Y7)) (fun mark>axxsel) (fun mark=mark) subterm comparison of args w. Mul Mul (meta X7)[is acc in sel(X7,Y7)] [is positive in sel(X7,Y7)] [is acc in X7] (fun mark=mark) subterm comparison of args w. Mul Mul (meta Y7)[is acc in sel(X7,Y7)] [is positive in sel(X7,Y7)] [is acc in Y7] >>True Checking (24) mark(tail(U7)) => axxtail(mark(U7)) (fun mark>axxtail) (fun mark=mark) subterm comparison of args w. Mul Mul (meta U7)[is acc in tail(U7)] [is positive in tail(U7)] [is acc in U7] >>True Checking (25) mark(take(V7,W7)) => axxtake(mark(V7),mark(W7)) (fun mark=axxtake) subterm comparison of args w. Mul Mul >>False Found constructors: nil, cons Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>OK Checking (44) foldr(%Y.%X.Z12[%Y,%X],U12,nil) => U12 (meta U12)[is acc in %Y.%X.Z12[%Y,%X],U12,nil] [is acc in U12] >>True Checking (45) foldr(%U.%Z.H12[%U,%Z],W12,cons(P12,X13)) => H12[P12,foldr(%W.%V.H12[%W,%V],W12,X13)] (meta H12)[is acc in %U.%Z.H12[%U,%Z],W12,cons(P12,X13)] [is acc in H12[%U,%Z]] (meta P12)[is acc in %U.%Z.H12[%U,%Z],W12,cons(P12,X13)] [is positive in cons(P12,X13)] [is acc in P12] (fun foldr=foldr) subterm comparison of args w. LR LR (meta H12)[is acc in %U.%Z.H12[%U,%Z],W12,cons(P12,X13)] [is acc in H12[%U,%Z]] (meta W12)[is acc in %U.%Z.H12[%U,%Z],W12,cons(P12,X13)] [is acc in W12] (meta X13)[is acc in %U.%Z.H12[%U,%Z],W12,cons(P12,X13)] [is positive in cons(P12,X13)] [is acc in X13] >>True #SN! ******** Signature ******** 0 : A afterNth : (A,A) -> A and : (A,A) -> A axxafterNth : (A,A) -> A axxand : (A,A) -> A axxfst : A -> A axxhead : A -> A axxnatsFrom : A -> A axxsel : (A,A) -> A axxsnd : A -> A axxsplitAt : (A,A) -> A axxtail : A -> A axxtake : (A,A) -> A axxu11 : (A,A,A,A) -> A axxu12 : (A,A) -> A cons : (A,A) -> A foldr : (((A,A) -> A),A,A) -> A fst : A -> A head : A -> A mark : A -> A natsFrom : A -> A nil : A pair : (A,A) -> A s : A -> A sel : (A,A) -> A snd : A -> A splitAt : (A,A) -> A tail : A -> A take : (A,A) -> A tt : A u11 : (A,A,A,A) -> A u12 : (A,A) -> A ******** Computation Rules ******** (1) axxu11(tt,X,Y,U) => axxu12(axxsplitAt(mark(X),mark(U)),Y) (2) axxu12(pair(V,W),P) => pair(cons(mark(P),V),mark(W)) (3) axxafterNth(X1,Y1) => axxsnd(axxsplitAt(mark(X1),mark(Y1))) (4) axxand(tt,U1) => mark(U1) (5) axxfst(pair(V1,W1)) => mark(V1) (6) axxhead(cons(P1,X2)) => mark(P1) (7) axxnatsFrom(Y2) => cons(mark(Y2),natsFrom(s(Y2))) (8) axxsel(U2,V2) => axxhead(axxafterNth(mark(U2),mark(V2))) (9) axxsnd(pair(W2,P2)) => mark(P2) (10) axxsplitAt(0,X3) => pair(nil,mark(X3)) (11) axxsplitAt(s(Y3),cons(U3,V3)) => axxu11(tt,Y3,U3,V3) (12) axxtail(cons(W3,P3)) => mark(P3) (13) axxtake(X4,Y4) => axxfst(axxsplitAt(mark(X4),mark(Y4))) (14) mark(u11(U4,V4,W4,P4)) => axxu11(mark(U4),V4,W4,P4) (15) mark(u12(X5,Y5)) => axxu12(mark(X5),Y5) (16) mark(splitAt(U5,V5)) => axxsplitAt(mark(U5),mark(V5)) (17) mark(afterNth(W5,P5)) => axxafterNth(mark(W5),mark(P5)) (18) mark(snd(X6)) => axxsnd(mark(X6)) (19) mark(and(Y6,U6)) => axxand(mark(Y6),U6) (20) mark(fst(V6)) => axxfst(mark(V6)) (21) mark(head(W6)) => axxhead(mark(W6)) (22) mark(natsFrom(P6)) => axxnatsFrom(mark(P6)) (23) mark(sel(X7,Y7)) => axxsel(mark(X7),mark(Y7)) (24) mark(tail(U7)) => axxtail(mark(U7)) (25) mark(take(V7,W7)) => axxtake(mark(V7),mark(W7)) (26) mark(tt) => tt (27) mark(pair(P7,X8)) => pair(mark(P7),mark(X8)) (28) mark(cons(Y8,U8)) => cons(mark(Y8),U8) (29) mark(s(V8)) => s(mark(V8)) (30) mark(0) => 0 (31) mark(nil) => nil (32) axxu11(W8,P8,X9,Y9) => u11(W8,P8,X9,Y9) (33) axxu12(U9,V9) => u12(U9,V9) (34) axxsplitAt(W9,P9) => splitAt(W9,P9) (35) axxafterNth(X10,Y10) => afterNth(X10,Y10) (36) axxsnd(U10) => snd(U10) (37) axxand(V10,W10) => and(V10,W10) (38) axxfst(P10) => fst(P10) (39) axxhead(X11) => head(X11) (40) axxnatsFrom(Y11) => natsFrom(Y11) (41) axxsel(U11,V11) => sel(U11,V11) (42) axxtail(W11) => tail(W11) (43) axxtake(P11,X12) => take(P11,X12) (44) foldr(%Y.%X.Z12[%Y,%X],U12,nil) => U12 (45) foldr(%U.%Z.H12[%U,%Z],W12,cons(P12,X13)) => H12[P12,foldr(%W.%V.H12[%W,%V],W12,X13)] YES