/export/starexec/sandbox2/solver/bin/starexec_run_default /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/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: axxu101(tt(),X,Y) -> axxfst(axxsplitAt(mark(X),mark(Y))) 2: axxu11(tt(),U,V) -> axxsnd(axxsplitAt(mark(U),mark(V))) 3: axxu21(tt(),W) -> mark(W) 4: axxu31(tt(),P) -> mark(P) 5: axxu41(tt(),X1) -> cons(mark(X1),natsFrom(s(X1))) 6: axxu51(tt(),Y1,U1) -> axxhead(axxafterNth(mark(Y1),mark(U1))) 7: axxu61(tt(),V1) -> mark(V1) 8: axxu71(tt(),W1) -> pair(nil(),mark(W1)) 9: axxu81(tt(),P1,X2,Y2) -> axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) 10: axxu82(pair(U2,V2),W2) -> pair(cons(mark(W2),U2),mark(V2)) 11: axxu91(tt(),P2) -> mark(P2) 12: axxafterNth(X3,Y3) -> axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) 13: axxand(tt(),U3) -> mark(U3) 14: axxfst(pair(V3,W3)) -> axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) 15: axxhead(cons(P3,X4)) -> axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) 16: axxisLNat(nil()) -> tt() 17: axxisLNat(afterNth(Y4,U4)) -> axxand(axxisNatural(Y4),isLNat(U4)) 18: axxisLNat(cons(V4,W4)) -> axxand(axxisNatural(V4),isLNat(W4)) 19: axxisLNat(fst(P4)) -> axxisPLNat(P4) 20: axxisLNat(natsFrom(X5)) -> axxisNatural(X5) 21: axxisLNat(snd(Y5)) -> axxisPLNat(Y5) 22: axxisLNat(tail(U5)) -> axxisLNat(U5) 23: axxisLNat(take(V5,W5)) -> axxand(axxisNatural(V5),isLNat(W5)) 24: axxisNatural(0()) -> tt() 25: axxisNatural(head(P5)) -> axxisLNat(P5) 26: axxisNatural(s(X6)) -> axxisNatural(X6) 27: axxisNatural(sel(Y6,U6)) -> axxand(axxisNatural(Y6),isLNat(U6)) 28: axxisPLNat(pair(V6,W6)) -> axxand(axxisLNat(V6),isLNat(W6)) 29: axxisPLNat(splitAt(P6,X7)) -> axxand(axxisNatural(P6),isLNat(X7)) 30: axxnatsFrom(Y7) -> axxu41(axxisNatural(Y7),Y7) 31: axxsel(U7,V7) -> axxu51(axxand(axxisNatural(U7),isLNat(V7)),U7,V7) 32: axxsnd(pair(W7,P7)) -> axxu61(axxand(axxisLNat(W7),isLNat(P7)),P7) 33: axxsplitAt(0(),X8) -> axxu71(axxisLNat(X8),X8) 34: axxsplitAt(s(Y8),cons(U8,V8)) -> axxu81(axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))),Y8,U8,V8) 35: axxtail(cons(W8,P8)) -> axxu91(axxand(axxisNatural(W8),isLNat(P8)),P8) 36: axxtake(X9,Y9) -> axxu101(axxand(axxisNatural(X9),isLNat(Y9)),X9,Y9) 37: mark(u101(U9,V9,W9)) -> axxu101(mark(U9),V9,W9) 38: mark(fst(P9)) -> axxfst(mark(P9)) 39: mark(splitAt(X10,Y10)) -> axxsplitAt(mark(X10),mark(Y10)) 40: mark(u11(U10,V10,W10)) -> axxu11(mark(U10),V10,W10) 41: mark(snd(P10)) -> axxsnd(mark(P10)) 42: mark(u21(X11,Y11)) -> axxu21(mark(X11),Y11) 43: mark(u31(U11,V11)) -> axxu31(mark(U11),V11) 44: mark(u41(W11,P11)) -> axxu41(mark(W11),P11) 45: mark(natsFrom(X12)) -> axxnatsFrom(mark(X12)) 46: mark(u51(Y12,U12,V12)) -> axxu51(mark(Y12),U12,V12) 47: mark(head(W12)) -> axxhead(mark(W12)) 48: mark(afterNth(P12,X13)) -> axxafterNth(mark(P12),mark(X13)) 49: mark(u61(Y13,U13)) -> axxu61(mark(Y13),U13) 50: mark(u71(V13,W13)) -> axxu71(mark(V13),W13) 51: mark(u81(P13,X14,Y14,U14)) -> axxu81(mark(P13),X14,Y14,U14) 52: mark(u82(V14,W14)) -> axxu82(mark(V14),W14) 53: mark(u91(P14,X15)) -> axxu91(mark(P14),X15) 54: mark(and(Y15,U15)) -> axxand(mark(Y15),U15) 55: mark(isNatural(V15)) -> axxisNatural(V15) 56: mark(isLNat(W15)) -> axxisLNat(W15) 57: mark(isPLNat(P15)) -> axxisPLNat(P15) 58: mark(tail(X16)) -> axxtail(mark(X16)) 59: mark(take(Y16,U16)) -> axxtake(mark(Y16),mark(U16)) 60: mark(sel(V16,W16)) -> axxsel(mark(V16),mark(W16)) 61: mark(tt()) -> tt() 62: mark(cons(P16,X17)) -> cons(mark(P16),X17) 63: mark(s(Y17)) -> s(mark(Y17)) 64: mark(pair(U17,V17)) -> pair(mark(U17),mark(V17)) 65: mark(nil()) -> nil() 66: mark(0()) -> 0() 67: axxu101(W17,P17,X18) -> u101(W17,P17,X18) 68: axxfst(Y18) -> fst(Y18) 69: axxsplitAt(U18,V18) -> splitAt(U18,V18) 70: axxu11(W18,P18,X19) -> u11(W18,P18,X19) 71: axxsnd(Y19) -> snd(Y19) 72: axxu21(U19,V19) -> u21(U19,V19) 73: axxu31(W19,P19) -> u31(W19,P19) 74: axxu41(X20,Y20) -> u41(X20,Y20) 75: axxnatsFrom(U20) -> natsFrom(U20) 76: axxu51(V20,W20,P20) -> u51(V20,W20,P20) 77: axxhead(X21) -> head(X21) 78: axxafterNth(Y21,U21) -> afterNth(Y21,U21) 79: axxu61(V21,W21) -> u61(V21,W21) 80: axxu71(P21,X22) -> u71(P21,X22) 81: axxu81(Y22,U22,V22,W22) -> u81(Y22,U22,V22,W22) 82: axxu82(P22,X23) -> u82(P22,X23) 83: axxu91(Y23,U23) -> u91(Y23,U23) 84: axxand(V23,W23) -> and(V23,W23) 85: axxisNatural(P23) -> isNatural(P23) 86: axxisLNat(X24) -> isLNat(X24) 87: axxisPLNat(Y24) -> isPLNat(Y24) 88: axxtail(U24) -> tail(U24) 89: axxtake(V24,W24) -> take(V24,W24) 90: axxsel(P24,X25) -> sel(P24,X25) 91: _(X1,X2) -> X1 92: _(X1,X2) -> X2 Number of strict rules: 92 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #axxu11(tt(),U,V) -> #axxsnd(axxsplitAt(mark(U),mark(V))) #2: #axxu11(tt(),U,V) -> #axxsplitAt(mark(U),mark(V)) #3: #axxu11(tt(),U,V) -> #mark(U) #4: #axxu11(tt(),U,V) -> #mark(V) #5: #mark(u31(U11,V11)) -> #axxu31(mark(U11),V11) #6: #mark(u31(U11,V11)) -> #mark(U11) #7: #axxisPLNat(splitAt(P6,X7)) -> #axxand(axxisNatural(P6),isLNat(X7)) #8: #axxisPLNat(splitAt(P6,X7)) -> #axxisNatural(P6) #9: #axxtail(cons(W8,P8)) -> #axxu91(axxand(axxisNatural(W8),isLNat(P8)),P8) #10: #axxtail(cons(W8,P8)) -> #axxand(axxisNatural(W8),isLNat(P8)) #11: #axxtail(cons(W8,P8)) -> #axxisNatural(W8) #12: #mark(u51(Y12,U12,V12)) -> #axxu51(mark(Y12),U12,V12) #13: #mark(u51(Y12,U12,V12)) -> #mark(Y12) #14: #mark(u21(X11,Y11)) -> #axxu21(mark(X11),Y11) #15: #mark(u21(X11,Y11)) -> #mark(X11) #16: #mark(snd(P10)) -> #axxsnd(mark(P10)) #17: #mark(snd(P10)) -> #mark(P10) #18: #mark(u101(U9,V9,W9)) -> #axxu101(mark(U9),V9,W9) #19: #mark(u101(U9,V9,W9)) -> #mark(U9) #20: #mark(head(W12)) -> #axxhead(mark(W12)) #21: #mark(head(W12)) -> #mark(W12) #22: #mark(u91(P14,X15)) -> #axxu91(mark(P14),X15) #23: #mark(u91(P14,X15)) -> #mark(P14) #24: #mark(afterNth(P12,X13)) -> #axxafterNth(mark(P12),mark(X13)) #25: #mark(afterNth(P12,X13)) -> #mark(P12) #26: #mark(afterNth(P12,X13)) -> #mark(X13) #27: #mark(tail(X16)) -> #axxtail(mark(X16)) #28: #mark(tail(X16)) -> #mark(X16) #29: #mark(fst(P9)) -> #axxfst(mark(P9)) #30: #mark(fst(P9)) -> #mark(P9) #31: #axxu51(tt(),Y1,U1) -> #axxhead(axxafterNth(mark(Y1),mark(U1))) #32: #axxu51(tt(),Y1,U1) -> #axxafterNth(mark(Y1),mark(U1)) #33: #axxu51(tt(),Y1,U1) -> #mark(Y1) #34: #axxu51(tt(),Y1,U1) -> #mark(U1) #35: #mark(take(Y16,U16)) -> #axxtake(mark(Y16),mark(U16)) #36: #mark(take(Y16,U16)) -> #mark(Y16) #37: #mark(take(Y16,U16)) -> #mark(U16) #38: #mark(isNatural(V15)) -> #axxisNatural(V15) #39: #mark(u11(U10,V10,W10)) -> #axxu11(mark(U10),V10,W10) #40: #mark(u11(U10,V10,W10)) -> #mark(U10) #41: #mark(u81(P13,X14,Y14,U14)) -> #axxu81(mark(P13),X14,Y14,U14) #42: #mark(u81(P13,X14,Y14,U14)) -> #mark(P13) #43: #axxand(tt(),U3) -> #mark(U3) #44: #axxu81(tt(),P1,X2,Y2) -> #axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) #45: #axxu81(tt(),P1,X2,Y2) -> #axxsplitAt(mark(P1),mark(Y2)) #46: #axxu81(tt(),P1,X2,Y2) -> #mark(P1) #47: #axxu81(tt(),P1,X2,Y2) -> #mark(Y2) #48: #axxu91(tt(),P2) -> #mark(P2) #49: #mark(isPLNat(P15)) -> #axxisPLNat(P15) #50: #axxisLNat(take(V5,W5)) -> #axxand(axxisNatural(V5),isLNat(W5)) #51: #axxisLNat(take(V5,W5)) -> #axxisNatural(V5) #52: #mark(natsFrom(X12)) -> #axxnatsFrom(mark(X12)) #53: #mark(natsFrom(X12)) -> #mark(X12) #54: #axxafterNth(X3,Y3) -> #axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) #55: #axxafterNth(X3,Y3) -> #axxand(axxisNatural(X3),isLNat(Y3)) #56: #axxafterNth(X3,Y3) -> #axxisNatural(X3) #57: #axxsel(U7,V7) -> #axxu51(axxand(axxisNatural(U7),isLNat(V7)),U7,V7) #58: #axxsel(U7,V7) -> #axxand(axxisNatural(U7),isLNat(V7)) #59: #axxsel(U7,V7) -> #axxisNatural(U7) #60: #mark(isLNat(W15)) -> #axxisLNat(W15) #61: #axxfst(pair(V3,W3)) -> #axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) #62: #axxfst(pair(V3,W3)) -> #axxand(axxisLNat(V3),isLNat(W3)) #63: #axxfst(pair(V3,W3)) -> #axxisLNat(V3) #64: #mark(cons(P16,X17)) -> #mark(P16) #65: #axxnatsFrom(Y7) -> #axxu41(axxisNatural(Y7),Y7) #66: #axxnatsFrom(Y7) -> #axxisNatural(Y7) #67: #mark(u82(V14,W14)) -> #axxu82(mark(V14),W14) #68: #mark(u82(V14,W14)) -> #mark(V14) #69: #mark(u61(Y13,U13)) -> #axxu61(mark(Y13),U13) #70: #mark(u61(Y13,U13)) -> #mark(Y13) #71: #axxisNatural(head(P5)) -> #axxisLNat(P5) #72: #axxisLNat(natsFrom(X5)) -> #axxisNatural(X5) #73: #axxu61(tt(),V1) -> #mark(V1) #74: #mark(splitAt(X10,Y10)) -> #axxsplitAt(mark(X10),mark(Y10)) #75: #mark(splitAt(X10,Y10)) -> #mark(X10) #76: #mark(splitAt(X10,Y10)) -> #mark(Y10) #77: #axxu82(pair(U2,V2),W2) -> #mark(W2) #78: #axxu82(pair(U2,V2),W2) -> #mark(V2) #79: #mark(pair(U17,V17)) -> #mark(U17) #80: #mark(pair(U17,V17)) -> #mark(V17) #81: #axxsplitAt(0(),X8) -> #axxu71(axxisLNat(X8),X8) #82: #axxsplitAt(0(),X8) -> #axxisLNat(X8) #83: #axxu41(tt(),X1) -> #mark(X1) #84: #mark(u41(W11,P11)) -> #axxu41(mark(W11),P11) #85: #mark(u41(W11,P11)) -> #mark(W11) #86: #axxisPLNat(pair(V6,W6)) -> #axxand(axxisLNat(V6),isLNat(W6)) #87: #axxisPLNat(pair(V6,W6)) -> #axxisLNat(V6) #88: #axxisLNat(tail(U5)) -> #axxisLNat(U5) #89: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxu81(axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))),Y8,U8,V8) #90: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))) #91: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxisNatural(Y8) #92: #axxisNatural(sel(Y6,U6)) -> #axxand(axxisNatural(Y6),isLNat(U6)) #93: #axxisNatural(sel(Y6,U6)) -> #axxisNatural(Y6) #94: #mark(sel(V16,W16)) -> #axxsel(mark(V16),mark(W16)) #95: #mark(sel(V16,W16)) -> #mark(V16) #96: #mark(sel(V16,W16)) -> #mark(W16) #97: #axxisLNat(afterNth(Y4,U4)) -> #axxand(axxisNatural(Y4),isLNat(U4)) #98: #axxisLNat(afterNth(Y4,U4)) -> #axxisNatural(Y4) #99: #axxsnd(pair(W7,P7)) -> #axxu61(axxand(axxisLNat(W7),isLNat(P7)),P7) #100: #axxsnd(pair(W7,P7)) -> #axxand(axxisLNat(W7),isLNat(P7)) #101: #axxsnd(pair(W7,P7)) -> #axxisLNat(W7) #102: #axxisLNat(fst(P4)) -> #axxisPLNat(P4) #103: #mark(s(Y17)) -> #mark(Y17) #104: #axxisNatural(s(X6)) -> #axxisNatural(X6) #105: #axxtake(X9,Y9) -> #axxu101(axxand(axxisNatural(X9),isLNat(Y9)),X9,Y9) #106: #axxtake(X9,Y9) -> #axxand(axxisNatural(X9),isLNat(Y9)) #107: #axxtake(X9,Y9) -> #axxisNatural(X9) #108: #axxisLNat(snd(Y5)) -> #axxisPLNat(Y5) #109: #axxu21(tt(),W) -> #mark(W) #110: #axxu101(tt(),X,Y) -> #axxfst(axxsplitAt(mark(X),mark(Y))) #111: #axxu101(tt(),X,Y) -> #axxsplitAt(mark(X),mark(Y)) #112: #axxu101(tt(),X,Y) -> #mark(X) #113: #axxu101(tt(),X,Y) -> #mark(Y) #114: #mark(and(Y15,U15)) -> #axxand(mark(Y15),U15) #115: #mark(and(Y15,U15)) -> #mark(Y15) #116: #axxu71(tt(),W1) -> #mark(W1) #117: #axxhead(cons(P3,X4)) -> #axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) #118: #axxhead(cons(P3,X4)) -> #axxand(axxisNatural(P3),isLNat(X4)) #119: #axxhead(cons(P3,X4)) -> #axxisNatural(P3) #120: #axxu31(tt(),P) -> #mark(P) #121: #mark(u71(V13,W13)) -> #axxu71(mark(V13),W13) #122: #mark(u71(V13,W13)) -> #mark(V13) #123: #axxisLNat(cons(V4,W4)) -> #axxand(axxisNatural(V4),isLNat(W4)) #124: #axxisLNat(cons(V4,W4)) -> #axxisNatural(V4) Number of SCCs: 1, DPs: 124 SCC { #1..124 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1, x2 + 5, x3 + 9, x4 + 10) #axxu51 w: max(x2 + 26, x3 + 26) s w: x1 axxisLNat w: x1 u91 w: max(x1, x2) #axxu82 w: max(x1, x2) isPLNat w: x1 + 1 axxsnd w: x1 + 12 axxu11 w: max(x1 + 12, x2 + 23, x3 + 22) #axxu101 w: max(x2 + 11, x3 + 7675) #axxisLNat w: x1 take w: max(x1 + 7677, x2 + 7676) and w: max(x1, x2) axxsplitAt w: max(x1 + 5, x2 + 10) pair w: max(x1 + 7, x2 + 9) axxu91 w: max(x1, x2) fst w: x1 + 3770 axxand w: max(x1, x2) natsFrom w: x1 splitAt w: max(x1 + 5, x2 + 10) #axxu11 w: max(x1 + 8, x2 + 11, x3 + 11) u61 w: max(x1 + 8, x2 + 7) axxu31 w: max(x1 + 2, x2 + 3) _ w: 0 isNatural w: x1 #axxsplitAt w: max(x1 + 5, x2 + 10) axxnatsFrom w: x1 u41 w: max(x1, x2) axxisNatural w: x1 #axxu91 w: max(x1, x2) tail w: x1 u51 w: max(x1 + 29, x2 + 28, x3 + 27) #axxafterNth w: max(x1 + 14, x2 + 12) #mark w: x1 #axxtail w: x1 0 w: 4 axxu82 w: max(x1, x2 + 7) #axxnatsFrom w: x1 axxu81 w: max(x1, x2 + 5, x3 + 9, x4 + 10) axxisPLNat w: x1 + 1 #axxisPLNat w: x1 u11 w: max(x1 + 12, x2 + 23, x3 + 22) sel w: max(x1 + 17253, x2 + 24180) afterNth w: max(x1 + 23, x2 + 22) nil w: 4 #axxsnd w: x1 isLNat w: x1 #axxu21 w: max(x2 + 6) axxu41 w: max(x1, x2) axxafterNth w: max(x1 + 23, x2 + 22) mark w: x1 axxu71 w: max(x1 + 7, x2 + 10) u101 w: max(x1, x2 + 7677, x3 + 7676) #axxu81 w: max(x2 + 5, x3, x4 + 10) axxsel w: max(x1 + 17253, x2 + 24180) u21 w: max(x1, x2 + 126) axxfst w: x1 + 3770 axxu61 w: max(x1 + 8, x2 + 7) u82 w: max(x1, x2 + 7) #_ w: 0 #axxu31 w: max(x2 + 1) #axxsel w: max(x1 + 14553, x2 + 11634) #axxand w: max(x2) axxu51 w: max(x1 + 29, x2 + 28, x3 + 27) head w: x1 + 5 cons w: max(x1, x2) snd w: x1 + 12 #axxu41 w: max(x2) axxtail w: x1 tt w: 4 u71 w: max(x1 + 7, x2 + 10) axxtake w: max(x1 + 7677, x2 + 7676) #axxu61 w: max(x2 + 1) #axxfst w: x1 axxu101 w: max(x1, x2 + 7677, x3 + 7676) #axxu71 w: max(x2 + 8) #axxisNatural w: x1 u31 w: max(x1 + 2, x2 + 3) axxu21 w: max(x1, x2 + 126) #axxtake w: max(x1 + 2525, x2 + 7675) #axxhead w: x1 + 2 axxhead w: x1 + 5 USABLE RULES: { 1..90 } Removed DPs: #1..8 #12..14 #16..18 #20 #21 #24..26 #29..37 #39 #40 #46 #47 #49..51 #54..59 #61..63 #69..71 #73 #75 #76 #78..82 #86 #87 #90..102 #106..113 #116..122 Number of SCCs: 2, DPs: 33 SCC { #104 } POLO(Sum)... succeeded. u81 w: x2 + x3 + 4 #axxu51 w: 0 s w: x1 + 2154 axxisLNat w: x1 + 8 u91 w: 2 #axxu82 w: 0 isPLNat w: x1 + 7998 axxsnd w: 2 axxu11 w: x2 + x3 + 1 #axxu101 w: 1 #axxisLNat w: 1 take w: 3 and w: 1 axxsplitAt w: 8 pair w: x1 + 1261 axxu91 w: x1 + x2 + 3 fst w: x1 + 7988 axxand w: x2 + 5 natsFrom w: x1 + 9976 splitAt w: 1 #axxu11 w: 1 u61 w: 6392 axxu31 w: x1 + x2 + 1680 _ w: 0 isNatural w: 6204 #axxsplitAt w: 1 axxnatsFrom w: x1 + 9977 u41 w: 1137 axxisNatural w: x1 + 1 #axxu91 w: 1 tail w: 1 u51 w: x1 + 4 #axxafterNth w: 1 #mark w: 1 #axxtail w: 1 0 w: 3 axxu82 w: x2 + 1268 #axxnatsFrom w: 1 axxu81 w: x1 + x2 + x4 + 3 axxisPLNat w: 7997 #axxisPLNat w: 1 u11 w: x2 + x3 + 1842 sel w: x1 + 3 afterNth w: x1 + x2 + 6 nil w: 9 #axxsnd w: 0 isLNat w: x1 + 1 #axxu21 w: 1 axxu41 w: x2 + 9983 axxafterNth w: x1 + x2 mark w: x1 + 6 axxu71 w: x2 + 9 u101 w: 7979 #axxu81 w: 1 axxsel w: 10 u21 w: 6272 axxfst w: 7987 axxu61 w: x2 + 3 u82 w: 1261 #_ w: 0 #axxu31 w: 0 #axxsel w: 1 #axxand w: 1 axxu51 w: x2 + 11 head w: 6 cons w: x1 + x2 + 2 snd w: 2061 #axxu41 w: 1 axxtail w: x1 + 2 tt w: 11 u71 w: x2 + 2 axxtake w: 7 #axxu61 w: 1 #axxfst w: 1 axxu101 w: x3 + 7986 #axxu71 w: 1 #axxisNatural w: x1 + 1 u31 w: 1679 axxu21 w: x2 + 7988 #axxtake w: 1 #axxhead w: 1 axxhead w: 14 USABLE RULES: { } Removed DPs: #104 Number of SCCs: 1, DPs: 32 SCC { #9 #10 #15 #19 #22 #23 #27 #28 #41..45 #48 #52 #53 #60 #64 #65 #67 #68 #74 #77 #83..85 #88 #89 #103 #114 #115 #123 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1, x2 + 3, x3 + 5, x4 + 6) #axxu51 w: 0 s w: x1 axxisLNat w: x1 u91 w: max(x1, x2) #axxu82 w: max(x2 + 5) isPLNat w: x1 + 1 axxsnd w: x1 + 16 axxu11 w: max(x1 + 8, x2 + 23, x3 + 22) #axxu101 w: 0 #axxisLNat w: x1 + 4 take w: max(x1 + 9589, x2 + 7676) and w: max(x1, x2) axxsplitAt w: max(x1 + 3, x2 + 6) pair w: max(x1 + 5, x2 + 6) axxu91 w: max(x1, x2) fst w: x1 + 3770 axxand w: max(x1, x2) natsFrom w: x1 splitAt w: max(x1 + 3, x2 + 6) #axxu11 w: max(x1 + 8) u61 w: max(x1 + 16, x2 + 14) axxu31 w: max(x1 + 2, x2 + 4) _ w: 0 isNatural w: x1 #axxsplitAt w: max(x2 + 6) axxnatsFrom w: x1 u41 w: max(x1, x2) axxisNatural w: x1 #axxu91 w: max(x1 + 1, x2 + 4) tail w: x1 + 3020 u51 w: max(x1 + 29, x2 + 28, x3 + 27) #axxafterNth w: max(x1 + 14, x2 + 12) #mark w: x1 + 4 #axxtail w: x1 + 4 0 w: 2 axxu82 w: max(x1, x2 + 5) #axxnatsFrom w: x1 + 4 axxu81 w: max(x1, x2 + 3, x3 + 5, x4 + 6) axxisPLNat w: x1 + 1 #axxisPLNat w: 0 u11 w: max(x1 + 8, x2 + 23, x3 + 22) sel w: max(x1 + 17253, x2 + 20892) afterNth w: max(x1 + 23, x2 + 22) nil w: 2 #axxsnd w: x1 isLNat w: x1 #axxu21 w: 0 axxu41 w: max(x1, x2) axxafterNth w: max(x1 + 23, x2 + 22) mark w: x1 axxu71 w: max(x1 + 5, x2 + 6) u101 w: max(x1 + 1, x2 + 9149, x3 + 7676) #axxu81 w: max(x3 + 6, x4 + 6) axxsel w: max(x1 + 17253, x2 + 20892) u21 w: max(x1, x2 + 126) axxfst w: x1 + 3770 axxu61 w: max(x1 + 16, x2 + 14) u82 w: max(x1, x2 + 5) #_ w: 0 #axxu31 w: 0 #axxsel w: max(x1 + 14553, x2 + 11634) #axxand w: max(x2 + 4) axxu51 w: max(x1 + 29, x2 + 28, x3 + 27) head w: x1 + 5 cons w: max(x1, x2) snd w: x1 + 16 #axxu41 w: max(x1 + 3, x2 + 4) axxtail w: x1 + 3020 tt w: 2 u71 w: max(x1 + 5, x2 + 6) axxtake w: max(x1 + 9589, x2 + 7676) #axxu61 w: 0 #axxfst w: x1 axxu101 w: max(x1 + 1, x2 + 9149, x3 + 7676) #axxu71 w: 0 #axxisNatural w: 0 u31 w: max(x1 + 2, x2 + 4) axxu21 w: max(x1, x2 + 126) #axxtake w: max(x1 + 2525, x2 + 7675) #axxhead w: x1 + 2 axxhead w: x1 + 5 USABLE RULES: { 1..90 } Removed DPs: #19 #27 #28 #41 #44 #67 #74 #77 #88 Number of SCCs: 2, DPs: 21 SCC { #45 #89 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... succeeded. u81 s: [] p: 12 w: max(x3 + 16492, x4 + 23558) #axxu51 s: [] p: 0 w: x3 s s: [1] p: 3 w: x1 axxisLNat s: [] p: 7 w: x1 u91 s: [] p: 1 w: max(x2 + 5982) #axxu82 s: [] p: 0 w: x2 + 1 isPLNat s: [] p: 3 w: x1 axxsnd s: [1] p: 0 w: x1 + 2 axxu11 s: [] p: 2 w: max(x3 + 23560) #axxu101 s: [3,1,2] p: 0 w: max(x1, x2 + 1, x3) #axxisLNat s: [] p: 0 w: 0 take s: [] p: 1 w: x1 + x2 + 30654 and s: 2 axxsplitAt s: [2] p: 12 w: max(x2 + 23558) pair s: [] p: 1 w: max(x1 + 8750, x2 + 3) axxu91 s: [] p: 1 w: max(x2 + 5982) fst s: 1 axxand s: 2 natsFrom s: [] p: 9 w: x1 + 6262 splitAt s: [2] p: 12 w: max(x2 + 23558) #axxu11 s: [1,3] p: 0 w: x1 + x3 u61 s: [2,1] p: 3 w: max(x1 + 1, x2 + 2) axxu31 s: [2] p: 4 w: max(x1, x2) _ s: [] p: 0 w: x1 isNatural s: [1] p: 8 w: x1 #axxsplitAt s: [1] p: 1 w: max(x1 + 2583, x2 + 9112) axxnatsFrom s: [] p: 9 w: x1 + 6262 u41 s: [] p: 6 w: max(x1 + 5726, x2 + 6262) axxisNatural s: [1] p: 8 w: x1 #axxu91 s: [2,1] p: 0 w: max(x1, x2) tail s: [] p: 1 w: x1 + 11601 u51 s: [1] p: 4 w: max(x1 + 32386, x3 + 32385) #axxafterNth s: [1,2] p: 0 w: x1 + x2 + 1 #mark s: [] p: 0 w: 0 #axxtail s: [] p: 0 w: 1 0 s: [] p: 10 w: 5 axxu82 s: [] p: 1 w: max(x1, x2 + 11903) #axxnatsFrom s: [] p: 0 w: 1 axxu81 s: [] p: 12 w: max(x3 + 16492, x4 + 23558) axxisPLNat s: [] p: 3 w: x1 #axxisPLNat s: [] p: 0 w: 0 u11 s: [] p: 2 w: max(x3 + 23560) sel s: [] p: 6 w: x2 + 32387 afterNth s: [2] p: 3 w: max(x2 + 27195) nil s: [] p: 12 w: 5546 #axxsnd s: [] p: 0 w: 0 isLNat s: [] p: 7 w: x1 #axxu21 s: [] p: 0 w: x1 + 1 axxu41 s: [] p: 6 w: max(x1 + 5726, x2 + 6262) axxafterNth s: [2] p: 3 w: max(x2 + 27195) mark s: 1 axxu71 s: [2] p: 11 w: max(x2 + 14297) u101 s: [] p: 0 w: max(x1 + 30653, x3 + 27880) #axxu81 s: [2] p: 1 w: max(x2 + 2583, x3 + 9112, x4 + 9112) axxsel s: [] p: 6 w: x2 + 32387 u21 s: [] p: 4 w: max(x1 + 2, x2 + 1) axxfst s: 1 axxu61 s: [2,1] p: 3 w: max(x1 + 1, x2 + 2) u82 s: [] p: 1 w: max(x1, x2 + 11903) #_ s: [] p: 0 w: x2 + 1 #axxu31 s: [] p: 0 w: 1 #axxsel s: [] p: 0 w: 1 #axxand s: [] p: 0 w: max(x1 + 1) axxu51 s: [1] p: 4 w: max(x1 + 32386, x3 + 32385) head s: 1 cons s: [1] p: 5 w: max(x1, x2) snd s: [1] p: 0 w: x1 + 2 #axxu41 s: [2] p: 0 w: max(x2) axxtail s: [] p: 1 w: x1 + 11601 tt s: [] p: 10 w: 4 u71 s: [2] p: 11 w: max(x2 + 14297) axxtake s: [] p: 1 w: x1 + x2 + 30654 #axxu61 s: [2,1] p: 0 w: x1 + x2 #axxfst s: [] p: 0 w: 0 axxu101 s: [] p: 0 w: max(x1 + 30653, x3 + 27880) #axxu71 s: [1] p: 0 w: x1 #axxisNatural s: [] p: 0 w: 0 u31 s: [2] p: 4 w: max(x1, x2) axxu21 s: [] p: 4 w: max(x1 + 2, x2 + 1) #axxtake s: [2,1] p: 0 w: x1 + x2 #axxhead s: [] p: 0 w: 1 axxhead s: 1 USABLE RULES: { 1..90 } Removed DPs: #89 Number of SCCs: 1, DPs: 19 SCC { #15 #22 #23 #42 #43 #48 #52 #53 #60 #64 #65 #68 #83..85 #103 #114 #115 #123 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1 + 4, x2 + 4, x3 + 6, x4 + 3) #axxu51 w: 0 s w: x1 axxisLNat w: 2 u91 w: max(x1 + 3, x2 + 2) #axxu82 w: 0 isPLNat w: 2 axxsnd w: x1 + 3 axxu11 w: max(x2 + 7, x3 + 7) #axxu101 w: 0 #axxisLNat w: 2842 take w: max(x1 + 10786, x2 + 6180) and w: max(x1, x2) axxsplitAt w: max(x1 + 4, x2 + 3) pair w: max(x1, x2 + 3) axxu91 w: max(x1 + 3, x2 + 2) fst w: x1 + 2 axxand w: max(x1, x2) natsFrom w: x1 + 11800 splitAt w: max(x1 + 4, x2 + 3) #axxu11 w: 0 u61 w: max(x1 + 1, x2) axxu31 w: max(x2 + 9516) _ w: 0 isNatural w: 2 #axxsplitAt w: 0 axxnatsFrom w: x1 + 11800 u41 w: max(x1 + 5530, x2 + 11800) axxisNatural w: 2 #axxu91 w: max(x2 + 2841) tail w: x1 + 2 u51 w: max(x1 + 19933, x2 + 19934, x3 + 11819) #axxafterNth w: 0 #mark w: x1 + 2840 #axxtail w: 4 0 w: 8127 axxu82 w: max(x1, x2 + 6) #axxnatsFrom w: x1 + 8373 axxu81 w: max(x1 + 4, x2 + 4, x3 + 6, x4 + 3) axxisPLNat w: 2 #axxisPLNat w: 0 u11 w: max(x2 + 7, x3 + 7) sel w: max(x1 + 19934, x2 + 23192) afterNth w: max(x1 + 8, x2 + 7) nil w: 1 #axxsnd w: 0 isLNat w: 2 #axxu21 w: 0 axxu41 w: max(x1 + 5530, x2 + 11800) axxafterNth w: max(x1 + 8, x2 + 7) mark w: x1 axxu71 w: max(x1 + 3, x2 + 3) u101 w: max(x2 + 7684, x3 + 5) #axxu81 w: 0 axxsel w: max(x1 + 19934, x2 + 23192) u21 w: max(x1 + 1, x2 + 2) axxfst w: x1 + 2 axxu61 w: max(x1 + 1, x2) u82 w: max(x1, x2 + 6) #_ w: 0 #axxu31 w: 0 #axxsel w: 0 #axxand w: max(x1 + 750, x2 + 2840) axxu51 w: max(x1 + 19933, x2 + 19934, x3 + 11819) head w: x1 + 11811 cons w: max(x1 + 3, x2) snd w: x1 + 3 #axxu41 w: max(x1 + 8370, x2 + 2841) axxtail w: x1 + 2 tt w: 1 u71 w: max(x1 + 3, x2 + 3) axxtake w: max(x1 + 10786, x2 + 6180) #axxu61 w: 0 #axxfst w: 0 axxu101 w: max(x2 + 7684, x3 + 5) #axxu71 w: 0 #axxisNatural w: 0 u31 w: max(x2 + 9516) axxu21 w: max(x1 + 1, x2 + 2) #axxtake w: 0 #axxhead w: 2 axxhead w: x1 + 11811 USABLE RULES: { 1..90 } Removed DPs: #15 #22 #23 #42 #48 #52 #53 #64 #65 #83 #85 Number of SCCs: 1, DPs: 7 SCC { #43 #60 #68 #103 #114 #115 #123 } POLO(Sum)... succeeded. u81 w: x1 + 3838 #axxu51 w: 0 s w: x1 + 1 axxisLNat w: 3837 u91 w: 1 #axxu82 w: 1 isPLNat w: 3839 axxsnd w: x1 + 3 axxu11 w: x2 + x3 + 3837 #axxu101 w: 1 #axxisLNat w: x1 + 3840 take w: 3836 and w: x1 + x2 + 9 axxsplitAt w: x2 + 1343 pair w: 3839 axxu91 w: x1 + 1 fst w: 3838 axxand w: 8 natsFrom w: 1102 splitAt w: x1 + x2 + 1344 #axxu11 w: 1 u61 w: 3836 axxu31 w: 3836 _ w: 0 isNatural w: 2238 #axxsplitAt w: 1 axxnatsFrom w: x1 + 1101 u41 w: 1101 axxisNatural w: x1 + 1 #axxu91 w: 3 tail w: 12 u51 w: x2 + 3831 #axxafterNth w: 1 #mark w: x1 + 3 #axxtail w: 0 0 w: 3837 axxu82 w: x2 + 3838 #axxnatsFrom w: 3 axxu81 w: x2 + x3 + x4 + 3837 axxisPLNat w: x1 + 3838 #axxisPLNat w: 1 u11 w: x1 + 3838 sel w: x1 + x2 + 3 afterNth w: x1 + x2 + 5 nil w: 3837 #axxsnd w: 0 isLNat w: x1 + 3838 #axxu21 w: 1 axxu41 w: x1 + 1101 axxafterNth w: 4 mark w: 3836 axxu71 w: x2 + 3837 u101 w: x1 + x2 + 3838 #axxu81 w: 0 axxsel w: 3837 u21 w: 3839 axxfst w: 3837 axxu61 w: x1 + x2 + 3835 u82 w: x1 + 9533 #_ w: 0 #axxu31 w: 0 #axxsel w: 1 #axxand w: x2 + 4 axxu51 w: x1 + x3 + 3830 head w: x1 + 7671 cons w: x1 + x2 + 3 snd w: 4 #axxu41 w: 2 axxtail w: x1 + 11 tt w: 3839 u71 w: x1 + 3838 axxtake w: 3836 #axxu61 w: 1 #axxfst w: 1 axxu101 w: x3 + 3837 #axxu71 w: 1 #axxisNatural w: 1 u31 w: x1 + x2 + 3837 axxu21 w: x2 + 3838 #axxtake w: 1 #axxhead w: 1 axxhead w: 7670 USABLE RULES: { } Removed DPs: #43 #60 #68 #103 #114 #115 #123 Number of SCCs: 0, DPs: 0 ... Input TRS: 1: axxu101(tt(),X,Y) -> axxfst(axxsplitAt(mark(X),mark(Y))) 2: axxu11(tt(),U,V) -> axxsnd(axxsplitAt(mark(U),mark(V))) 3: axxu21(tt(),W) -> mark(W) 4: axxu31(tt(),P) -> mark(P) 5: axxu41(tt(),X1) -> cons(mark(X1),natsFrom(s(X1))) 6: axxu51(tt(),Y1,U1) -> axxhead(axxafterNth(mark(Y1),mark(U1))) 7: axxu61(tt(),V1) -> mark(V1) 8: axxu71(tt(),W1) -> pair(nil(),mark(W1)) 9: axxu81(tt(),P1,X2,Y2) -> axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) 10: axxu82(pair(U2,V2),W2) -> pair(cons(mark(W2),U2),mark(V2)) 11: axxu91(tt(),P2) -> mark(P2) 12: axxafterNth(X3,Y3) -> axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) 13: axxand(tt(),U3) -> mark(U3) 14: axxfst(pair(V3,W3)) -> axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) 15: axxhead(cons(P3,X4)) -> axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) 16: axxisLNat(nil()) -> tt() 17: axxisLNat(afterNth(Y4,U4)) -> axxand(axxisNatural(Y4),isLNat(U4)) 18: axxisLNat(cons(V4,W4)) -> axxand(axxisNatural(V4),isLNat(W4)) 19: axxisLNat(fst(P4)) -> axxisPLNat(P4) 20: axxisLNat(natsFrom(X5)) -> axxisNatural(X5) 21: axxisLNat(snd(Y5)) -> axxisPLNat(Y5) 22: axxisLNat(tail(U5)) -> axxisLNat(U5) 23: axxisLNat(take(V5,W5)) -> axxand(axxisNatural(V5),isLNat(W5)) 24: axxisNatural(0()) -> tt() 25: axxisNatural(head(P5)) -> axxisLNat(P5) 26: axxisNatural(s(X6)) -> axxisNatural(X6) 27: axxisNatural(sel(Y6,U6)) -> axxand(axxisNatural(Y6),isLNat(U6)) 28: axxisPLNat(pair(V6,W6)) -> axxand(axxisLNat(V6),isLNat(W6)) 29: axxisPLNat(splitAt(P6,X7)) -> axxand(axxisNatural(P6),isLNat(X7)) 30: axxnatsFrom(Y7) -> axxu41(axxisNatural(Y7),Y7) 31: axxsel(U7,V7) -> axxu51(axxand(axxisNatural(U7),isLNat(V7)),U7,V7) 32: axxsnd(pair(W7,P7)) -> axxu61(axxand(axxisLNat(W7),isLNat(P7)),P7) 33: axxsplitAt(0(),X8) -> axxu71(axxisLNat(X8),X8) 34: axxsplitAt(s(Y8),cons(U8,V8)) -> axxu81(axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))),Y8,U8,V8) 35: axxtail(cons(W8,P8)) -> axxu91(axxand(axxisNatural(W8),isLNat(P8)),P8) 36: axxtake(X9,Y9) -> axxu101(axxand(axxisNatural(X9),isLNat(Y9)),X9,Y9) 37: mark(u101(U9,V9,W9)) -> axxu101(mark(U9),V9,W9) 38: mark(fst(P9)) -> axxfst(mark(P9)) 39: mark(splitAt(X10,Y10)) -> axxsplitAt(mark(X10),mark(Y10)) 40: mark(u11(U10,V10,W10)) -> axxu11(mark(U10),V10,W10) 41: mark(snd(P10)) -> axxsnd(mark(P10)) 42: mark(u21(X11,Y11)) -> axxu21(mark(X11),Y11) 43: mark(u31(U11,V11)) -> axxu31(mark(U11),V11) 44: mark(u41(W11,P11)) -> axxu41(mark(W11),P11) 45: mark(natsFrom(X12)) -> axxnatsFrom(mark(X12)) 46: mark(u51(Y12,U12,V12)) -> axxu51(mark(Y12),U12,V12) 47: mark(head(W12)) -> axxhead(mark(W12)) 48: mark(afterNth(P12,X13)) -> axxafterNth(mark(P12),mark(X13)) 49: mark(u61(Y13,U13)) -> axxu61(mark(Y13),U13) 50: mark(u71(V13,W13)) -> axxu71(mark(V13),W13) 51: mark(u81(P13,X14,Y14,U14)) -> axxu81(mark(P13),X14,Y14,U14) 52: mark(u82(V14,W14)) -> axxu82(mark(V14),W14) 53: mark(u91(P14,X15)) -> axxu91(mark(P14),X15) 54: mark(and(Y15,U15)) -> axxand(mark(Y15),U15) 55: mark(isNatural(V15)) -> axxisNatural(V15) 56: mark(isLNat(W15)) -> axxisLNat(W15) 57: mark(isPLNat(P15)) -> axxisPLNat(P15) 58: mark(tail(X16)) -> axxtail(mark(X16)) 59: mark(take(Y16,U16)) -> axxtake(mark(Y16),mark(U16)) 60: mark(sel(V16,W16)) -> axxsel(mark(V16),mark(W16)) 61: mark(tt()) -> tt() 62: mark(cons(P16,X17)) -> cons(mark(P16),X17) 63: mark(s(Y17)) -> s(mark(Y17)) 64: mark(pair(U17,V17)) -> pair(mark(U17),mark(V17)) 65: mark(nil()) -> nil() 66: mark(0()) -> 0() 67: axxu101(W17,P17,X18) -> u101(W17,P17,X18) 68: axxfst(Y18) -> fst(Y18) 69: axxsplitAt(U18,V18) -> splitAt(U18,V18) 70: axxu11(W18,P18,X19) -> u11(W18,P18,X19) 71: axxsnd(Y19) -> snd(Y19) 72: axxu21(U19,V19) -> u21(U19,V19) 73: axxu31(W19,P19) -> u31(W19,P19) 74: axxu41(X20,Y20) -> u41(X20,Y20) 75: axxnatsFrom(U20) -> natsFrom(U20) 76: axxu51(V20,W20,P20) -> u51(V20,W20,P20) 77: axxhead(X21) -> head(X21) 78: axxafterNth(Y21,U21) -> afterNth(Y21,U21) 79: axxu61(V21,W21) -> u61(V21,W21) 80: axxu71(P21,X22) -> u71(P21,X22) 81: axxu81(Y22,U22,V22,W22) -> u81(Y22,U22,V22,W22) 82: axxu82(P22,X23) -> u82(P22,X23) 83: axxu91(Y23,U23) -> u91(Y23,U23) 84: axxand(V23,W23) -> and(V23,W23) 85: axxisNatural(P23) -> isNatural(P23) 86: axxisLNat(X24) -> isLNat(X24) 87: axxisPLNat(Y24) -> isPLNat(Y24) 88: axxtail(U24) -> tail(U24) 89: axxtake(V24,W24) -> take(V24,W24) 90: axxsel(P24,X25) -> sel(P24,X25) 91: _(X1,X2) -> X1 92: _(X1,X2) -> X2 Number of strict rules: 92 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #axxu11(tt(),U,V) -> #axxsnd(axxsplitAt(mark(U),mark(V))) #2: #axxu11(tt(),U,V) -> #axxsplitAt(mark(U),mark(V)) #3: #axxu11(tt(),U,V) -> #mark(U) #4: #axxu11(tt(),U,V) -> #mark(V) #5: #mark(u31(U11,V11)) -> #axxu31(mark(U11),V11) #6: #mark(u31(U11,V11)) -> #mark(U11) #7: #axxisPLNat(splitAt(P6,X7)) -> #axxand(axxisNatural(P6),isLNat(X7)) #8: #axxisPLNat(splitAt(P6,X7)) -> #axxisNatural(P6) #9: #axxtail(cons(W8,P8)) -> #axxu91(axxand(axxisNatural(W8),isLNat(P8)),P8) #10: #axxtail(cons(W8,P8)) -> #axxand(axxisNatural(W8),isLNat(P8)) #11: #axxtail(cons(W8,P8)) -> #axxisNatural(W8) #12: #mark(u51(Y12,U12,V12)) -> #axxu51(mark(Y12),U12,V12) #13: #mark(u51(Y12,U12,V12)) -> #mark(Y12) #14: #mark(u21(X11,Y11)) -> #axxu21(mark(X11),Y11) #15: #mark(u21(X11,Y11)) -> #mark(X11) #16: #mark(snd(P10)) -> #axxsnd(mark(P10)) #17: #mark(snd(P10)) -> #mark(P10) #18: #mark(u101(U9,V9,W9)) -> #axxu101(mark(U9),V9,W9) #19: #mark(u101(U9,V9,W9)) -> #mark(U9) #20: #mark(head(W12)) -> #axxhead(mark(W12)) #21: #mark(head(W12)) -> #mark(W12) #22: #mark(u91(P14,X15)) -> #axxu91(mark(P14),X15) #23: #mark(u91(P14,X15)) -> #mark(P14) #24: #mark(afterNth(P12,X13)) -> #axxafterNth(mark(P12),mark(X13)) #25: #mark(afterNth(P12,X13)) -> #mark(P12) #26: #mark(afterNth(P12,X13)) -> #mark(X13) #27: #mark(tail(X16)) -> #axxtail(mark(X16)) #28: #mark(tail(X16)) -> #mark(X16) #29: #mark(fst(P9)) -> #axxfst(mark(P9)) #30: #mark(fst(P9)) -> #mark(P9) #31: #axxu51(tt(),Y1,U1) -> #axxhead(axxafterNth(mark(Y1),mark(U1))) #32: #axxu51(tt(),Y1,U1) -> #axxafterNth(mark(Y1),mark(U1)) #33: #axxu51(tt(),Y1,U1) -> #mark(Y1) #34: #axxu51(tt(),Y1,U1) -> #mark(U1) #35: #mark(take(Y16,U16)) -> #axxtake(mark(Y16),mark(U16)) #36: #mark(take(Y16,U16)) -> #mark(Y16) #37: #mark(take(Y16,U16)) -> #mark(U16) #38: #mark(isNatural(V15)) -> #axxisNatural(V15) #39: #mark(u11(U10,V10,W10)) -> #axxu11(mark(U10),V10,W10) #40: #mark(u11(U10,V10,W10)) -> #mark(U10) #41: #mark(u81(P13,X14,Y14,U14)) -> #axxu81(mark(P13),X14,Y14,U14) #42: #mark(u81(P13,X14,Y14,U14)) -> #mark(P13) #43: #axxand(tt(),U3) -> #mark(U3) #44: #axxu81(tt(),P1,X2,Y2) -> #axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) #45: #axxu81(tt(),P1,X2,Y2) -> #axxsplitAt(mark(P1),mark(Y2)) #46: #axxu81(tt(),P1,X2,Y2) -> #mark(P1) #47: #axxu81(tt(),P1,X2,Y2) -> #mark(Y2) #48: #axxu91(tt(),P2) -> #mark(P2) #49: #mark(isPLNat(P15)) -> #axxisPLNat(P15) #50: #axxisLNat(take(V5,W5)) -> #axxand(axxisNatural(V5),isLNat(W5)) #51: #axxisLNat(take(V5,W5)) -> #axxisNatural(V5) #52: #mark(natsFrom(X12)) -> #axxnatsFrom(mark(X12)) #53: #mark(natsFrom(X12)) -> #mark(X12) #54: #axxafterNth(X3,Y3) -> #axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) #55: #axxafterNth(X3,Y3) -> #axxand(axxisNatural(X3),isLNat(Y3)) #56: #axxafterNth(X3,Y3) -> #axxisNatural(X3) #57: #axxsel(U7,V7) -> #axxu51(axxand(axxisNatural(U7),isLNat(V7)),U7,V7) #58: #axxsel(U7,V7) -> #axxand(axxisNatural(U7),isLNat(V7)) #59: #axxsel(U7,V7) -> #axxisNatural(U7) #60: #mark(isLNat(W15)) -> #axxisLNat(W15) #61: #axxfst(pair(V3,W3)) -> #axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) #62: #axxfst(pair(V3,W3)) -> #axxand(axxisLNat(V3),isLNat(W3)) #63: #axxfst(pair(V3,W3)) -> #axxisLNat(V3) #64: #mark(cons(P16,X17)) -> #mark(P16) #65: #axxnatsFrom(Y7) -> #axxu41(axxisNatural(Y7),Y7) #66: #axxnatsFrom(Y7) -> #axxisNatural(Y7) #67: #mark(u82(V14,W14)) -> #axxu82(mark(V14),W14) #68: #mark(u82(V14,W14)) -> #mark(V14) #69: #mark(u61(Y13,U13)) -> #axxu61(mark(Y13),U13) #70: #mark(u61(Y13,U13)) -> #mark(Y13) #71: #axxisNatural(head(P5)) -> #axxisLNat(P5) #72: #axxisLNat(natsFrom(X5)) -> #axxisNatural(X5) #73: #axxu61(tt(),V1) -> #mark(V1) #74: #mark(splitAt(X10,Y10)) -> #axxsplitAt(mark(X10),mark(Y10)) #75: #mark(splitAt(X10,Y10)) -> #mark(X10) #76: #mark(splitAt(X10,Y10)) -> #mark(Y10) #77: #axxu82(pair(U2,V2),W2) -> #mark(W2) #78: #axxu82(pair(U2,V2),W2) -> #mark(V2) #79: #mark(pair(U17,V17)) -> #mark(U17) #80: #mark(pair(U17,V17)) -> #mark(V17) #81: #axxsplitAt(0(),X8) -> #axxu71(axxisLNat(X8),X8) #82: #axxsplitAt(0(),X8) -> #axxisLNat(X8) #83: #axxu41(tt(),X1) -> #mark(X1) #84: #mark(u41(W11,P11)) -> #axxu41(mark(W11),P11) #85: #mark(u41(W11,P11)) -> #mark(W11) #86: #axxisPLNat(pair(V6,W6)) -> #axxand(axxisLNat(V6),isLNat(W6)) #87: #axxisPLNat(pair(V6,W6)) -> #axxisLNat(V6) #88: #axxisLNat(tail(U5)) -> #axxisLNat(U5) #89: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxu81(axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))),Y8,U8,V8) #90: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))) #91: #axxsplitAt(s(Y8),cons(U8,V8)) -> #axxisNatural(Y8) #92: #axxisNatural(sel(Y6,U6)) -> #axxand(axxisNatural(Y6),isLNat(U6)) #93: #axxisNatural(sel(Y6,U6)) -> #axxisNatural(Y6) #94: #mark(sel(V16,W16)) -> #axxsel(mark(V16),mark(W16)) #95: #mark(sel(V16,W16)) -> #mark(V16) #96: #mark(sel(V16,W16)) -> #mark(W16) #97: #axxisLNat(afterNth(Y4,U4)) -> #axxand(axxisNatural(Y4),isLNat(U4)) #98: #axxisLNat(afterNth(Y4,U4)) -> #axxisNatural(Y4) #99: #axxsnd(pair(W7,P7)) -> #axxu61(axxand(axxisLNat(W7),isLNat(P7)),P7) #100: #axxsnd(pair(W7,P7)) -> #axxand(axxisLNat(W7),isLNat(P7)) #101: #axxsnd(pair(W7,P7)) -> #axxisLNat(W7) #102: #axxisLNat(fst(P4)) -> #axxisPLNat(P4) #103: #mark(s(Y17)) -> #mark(Y17) #104: #axxisNatural(s(X6)) -> #axxisNatural(X6) #105: #axxtake(X9,Y9) -> #axxu101(axxand(axxisNatural(X9),isLNat(Y9)),X9,Y9) #106: #axxtake(X9,Y9) -> #axxand(axxisNatural(X9),isLNat(Y9)) #107: #axxtake(X9,Y9) -> #axxisNatural(X9) #108: #axxisLNat(snd(Y5)) -> #axxisPLNat(Y5) #109: #axxu21(tt(),W) -> #mark(W) #110: #axxu101(tt(),X,Y) -> #axxfst(axxsplitAt(mark(X),mark(Y))) #111: #axxu101(tt(),X,Y) -> #axxsplitAt(mark(X),mark(Y)) #112: #axxu101(tt(),X,Y) -> #mark(X) #113: #axxu101(tt(),X,Y) -> #mark(Y) #114: #mark(and(Y15,U15)) -> #axxand(mark(Y15),U15) #115: #mark(and(Y15,U15)) -> #mark(Y15) #116: #axxu71(tt(),W1) -> #mark(W1) #117: #axxhead(cons(P3,X4)) -> #axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) #118: #axxhead(cons(P3,X4)) -> #axxand(axxisNatural(P3),isLNat(X4)) #119: #axxhead(cons(P3,X4)) -> #axxisNatural(P3) #120: #axxu31(tt(),P) -> #mark(P) #121: #mark(u71(V13,W13)) -> #axxu71(mark(V13),W13) #122: #mark(u71(V13,W13)) -> #mark(V13) #123: #axxisLNat(cons(V4,W4)) -> #axxand(axxisNatural(V4),isLNat(W4)) #124: #axxisLNat(cons(V4,W4)) -> #axxisNatural(V4) Number of SCCs: 1, DPs: 124 SCC { #1..124 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1, x2 + 5, x3 + 9, x4 + 10) #axxu51 w: max(x2 + 26, x3 + 26) s w: x1 axxisLNat w: x1 u91 w: max(x1, x2) #axxu82 w: max(x1, x2) isPLNat w: x1 + 1 axxsnd w: x1 + 12 axxu11 w: max(x1 + 12, x2 + 23, x3 + 22) #axxu101 w: max(x2 + 11, x3 + 7675) #axxisLNat w: x1 take w: max(x1 + 7677, x2 + 7676) and w: max(x1, x2) axxsplitAt w: max(x1 + 5, x2 + 10) pair w: max(x1 + 7, x2 + 9) axxu91 w: max(x1, x2) fst w: x1 + 3770 axxand w: max(x1, x2) natsFrom w: x1 splitAt w: max(x1 + 5, x2 + 10) #axxu11 w: max(x1 + 8, x2 + 11, x3 + 11) u61 w: max(x1 + 8, x2 + 7) axxu31 w: max(x1 + 2, x2 + 3) _ w: 0 isNatural w: x1 #axxsplitAt w: max(x1 + 5, x2 + 10) axxnatsFrom w: x1 u41 w: max(x1, x2) axxisNatural w: x1 #axxu91 w: max(x1, x2) tail w: x1 u51 w: max(x1 + 29, x2 + 28, x3 + 27) #axxafterNth w: max(x1 + 14, x2 + 12) #mark w: x1 #axxtail w: x1 0 w: 4 axxu82 w: max(x1, x2 + 7) #axxnatsFrom w: x1 axxu81 w: max(x1, x2 + 5, x3 + 9, x4 + 10) axxisPLNat w: x1 + 1 #axxisPLNat w: x1 u11 w: max(x1 + 12, x2 + 23, x3 + 22) sel w: max(x1 + 17253, x2 + 24180) afterNth w: max(x1 + 23, x2 + 22) nil w: 4 #axxsnd w: x1 isLNat w: x1 #axxu21 w: max(x2 + 6) axxu41 w: max(x1, x2) axxafterNth w: max(x1 + 23, x2 + 22) mark w: x1 axxu71 w: max(x1 + 7, x2 + 10) u101 w: max(x1, x2 + 7677, x3 + 7676) #axxu81 w: max(x2 + 5, x3, x4 + 10) axxsel w: max(x1 + 17253, x2 + 24180) u21 w: max(x1, x2 + 126) axxfst w: x1 + 3770 axxu61 w: max(x1 + 8, x2 + 7) u82 w: max(x1, x2 + 7) #_ w: 0 #axxu31 w: max(x2 + 1) #axxsel w: max(x1 + 14553, x2 + 11634) #axxand w: max(x2) axxu51 w: max(x1 + 29, x2 + 28, x3 + 27) head w: x1 + 5 cons w: max(x1, x2) snd w: x1 + 12 #axxu41 w: max(x2) axxtail w: x1 tt w: 4 u71 w: max(x1 + 7, x2 + 10) axxtake w: max(x1 + 7677, x2 + 7676) #axxu61 w: max(x2 + 1) #axxfst w: x1 axxu101 w: max(x1, x2 + 7677, x3 + 7676) #axxu71 w: max(x2 + 8) #axxisNatural w: x1 u31 w: max(x1 + 2, x2 + 3) axxu21 w: max(x1, x2 + 126) #axxtake w: max(x1 + 2525, x2 + 7675) #axxhead w: x1 + 2 axxhead w: x1 + 5 USABLE RULES: { 1..90 } Removed DPs: #1..8 #12..14 #16..18 #20 #21 #24..26 #29..37 #39 #40 #46 #47 #49..51 #54..59 #61..63 #69..71 #73 #75 #76 #78..82 #86 #87 #90..102 #106..113 #116..122 Number of SCCs: 2, DPs: 33 SCC { #104 } POLO(Sum)... succeeded. u81 w: x2 + x3 + 4 #axxu51 w: 0 s w: x1 + 2154 axxisLNat w: x1 + 8 u91 w: 2 #axxu82 w: 0 isPLNat w: x1 + 7998 axxsnd w: 2 axxu11 w: x2 + x3 + 1 #axxu101 w: 1 #axxisLNat w: 1 take w: 3 and w: 1 axxsplitAt w: 8 pair w: x1 + 1261 axxu91 w: x1 + x2 + 3 fst w: x1 + 7988 axxand w: x2 + 5 natsFrom w: x1 + 9976 splitAt w: 1 #axxu11 w: 1 u61 w: 6392 axxu31 w: x1 + x2 + 1680 _ w: 0 isNatural w: 6204 #axxsplitAt w: 1 axxnatsFrom w: x1 + 9977 u41 w: 1137 axxisNatural w: x1 + 1 #axxu91 w: 1 tail w: 1 u51 w: x1 + 4 #axxafterNth w: 1 #mark w: 1 #axxtail w: 1 0 w: 3 axxu82 w: x2 + 1268 #axxnatsFrom w: 1 axxu81 w: x1 + x2 + x4 + 3 axxisPLNat w: 7997 #axxisPLNat w: 1 u11 w: x2 + x3 + 1842 sel w: x1 + 3 afterNth w: x1 + x2 + 6 nil w: 9 #axxsnd w: 0 isLNat w: x1 + 1 #axxu21 w: 1 axxu41 w: x2 + 9983 axxafterNth w: x1 + x2 mark w: x1 + 6 axxu71 w: x2 + 9 u101 w: 7979 #axxu81 w: 1 axxsel w: 10 u21 w: 6272 axxfst w: 7987 axxu61 w: x2 + 3 u82 w: 1261 #_ w: 0 #axxu31 w: 0 #axxsel w: 1 #axxand w: 1 axxu51 w: x2 + 11 head w: 6 cons w: x1 + x2 + 2 snd w: 2061 #axxu41 w: 1 axxtail w: x1 + 2 tt w: 11 u71 w: x2 + 2 axxtake w: 7 #axxu61 w: 1 #axxfst w: 1 axxu101 w: x3 + 7986 #axxu71 w: 1 #axxisNatural w: x1 + 1 u31 w: 1679 axxu21 w: x2 + 7988 #axxtake w: 1 #axxhead w: 1 axxhead w: 14 USABLE RULES: { } Removed DPs: #104 Number of SCCs: 1, DPs: 32 SCC { #9 #10 #15 #19 #22 #23 #27 #28 #41..45 #48 #52 #53 #60 #64 #65 #67 #68 #74 #77 #83..85 #88 #89 #103 #114 #115 #123 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1, x2 + 3, x3 + 5, x4 + 6) #axxu51 w: 0 s w: x1 axxisLNat w: x1 u91 w: max(x1, x2) #axxu82 w: max(x2 + 5) isPLNat w: x1 + 1 axxsnd w: x1 + 16 axxu11 w: max(x1 + 8, x2 + 23, x3 + 22) #axxu101 w: 0 #axxisLNat w: x1 + 4 take w: max(x1 + 9589, x2 + 7676) and w: max(x1, x2) axxsplitAt w: max(x1 + 3, x2 + 6) pair w: max(x1 + 5, x2 + 6) axxu91 w: max(x1, x2) fst w: x1 + 3770 axxand w: max(x1, x2) natsFrom w: x1 splitAt w: max(x1 + 3, x2 + 6) #axxu11 w: max(x1 + 8) u61 w: max(x1 + 16, x2 + 14) axxu31 w: max(x1 + 2, x2 + 4) _ w: 0 isNatural w: x1 #axxsplitAt w: max(x2 + 6) axxnatsFrom w: x1 u41 w: max(x1, x2) axxisNatural w: x1 #axxu91 w: max(x1 + 1, x2 + 4) tail w: x1 + 3020 u51 w: max(x1 + 29, x2 + 28, x3 + 27) #axxafterNth w: max(x1 + 14, x2 + 12) #mark w: x1 + 4 #axxtail w: x1 + 4 0 w: 2 axxu82 w: max(x1, x2 + 5) #axxnatsFrom w: x1 + 4 axxu81 w: max(x1, x2 + 3, x3 + 5, x4 + 6) axxisPLNat w: x1 + 1 #axxisPLNat w: 0 u11 w: max(x1 + 8, x2 + 23, x3 + 22) sel w: max(x1 + 17253, x2 + 20892) afterNth w: max(x1 + 23, x2 + 22) nil w: 2 #axxsnd w: x1 isLNat w: x1 #axxu21 w: 0 axxu41 w: max(x1, x2) axxafterNth w: max(x1 + 23, x2 + 22) mark w: x1 axxu71 w: max(x1 + 5, x2 + 6) u101 w: max(x1 + 1, x2 + 9149, x3 + 7676) #axxu81 w: max(x3 + 6, x4 + 6) axxsel w: max(x1 + 17253, x2 + 20892) u21 w: max(x1, x2 + 126) axxfst w: x1 + 3770 axxu61 w: max(x1 + 16, x2 + 14) u82 w: max(x1, x2 + 5) #_ w: 0 #axxu31 w: 0 #axxsel w: max(x1 + 14553, x2 + 11634) #axxand w: max(x2 + 4) axxu51 w: max(x1 + 29, x2 + 28, x3 + 27) head w: x1 + 5 cons w: max(x1, x2) snd w: x1 + 16 #axxu41 w: max(x1 + 3, x2 + 4) axxtail w: x1 + 3020 tt w: 2 u71 w: max(x1 + 5, x2 + 6) axxtake w: max(x1 + 9589, x2 + 7676) #axxu61 w: 0 #axxfst w: x1 axxu101 w: max(x1 + 1, x2 + 9149, x3 + 7676) #axxu71 w: 0 #axxisNatural w: 0 u31 w: max(x1 + 2, x2 + 4) axxu21 w: max(x1, x2 + 126) #axxtake w: max(x1 + 2525, x2 + 7675) #axxhead w: x1 + 2 axxhead w: x1 + 5 USABLE RULES: { 1..90 } Removed DPs: #19 #27 #28 #41 #44 #67 #74 #77 #88 Number of SCCs: 2, DPs: 21 SCC { #45 #89 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... succeeded. u81 s: [] p: 12 w: max(x3 + 16492, x4 + 23558) #axxu51 s: [] p: 0 w: x3 s s: [1] p: 3 w: x1 axxisLNat s: [] p: 7 w: x1 u91 s: [] p: 1 w: max(x2 + 5982) #axxu82 s: [] p: 0 w: x2 + 1 isPLNat s: [] p: 3 w: x1 axxsnd s: [1] p: 0 w: x1 + 2 axxu11 s: [] p: 2 w: max(x3 + 23560) #axxu101 s: [3,1,2] p: 0 w: max(x1, x2 + 1, x3) #axxisLNat s: [] p: 0 w: 0 take s: [] p: 1 w: x1 + x2 + 30654 and s: 2 axxsplitAt s: [2] p: 12 w: max(x2 + 23558) pair s: [] p: 1 w: max(x1 + 8750, x2 + 3) axxu91 s: [] p: 1 w: max(x2 + 5982) fst s: 1 axxand s: 2 natsFrom s: [] p: 9 w: x1 + 6262 splitAt s: [2] p: 12 w: max(x2 + 23558) #axxu11 s: [1,3] p: 0 w: x1 + x3 u61 s: [2,1] p: 3 w: max(x1 + 1, x2 + 2) axxu31 s: [2] p: 4 w: max(x1, x2) _ s: [] p: 0 w: x1 isNatural s: [1] p: 8 w: x1 #axxsplitAt s: [1] p: 1 w: max(x1 + 2583, x2 + 9112) axxnatsFrom s: [] p: 9 w: x1 + 6262 u41 s: [] p: 6 w: max(x1 + 5726, x2 + 6262) axxisNatural s: [1] p: 8 w: x1 #axxu91 s: [2,1] p: 0 w: max(x1, x2) tail s: [] p: 1 w: x1 + 11601 u51 s: [1] p: 4 w: max(x1 + 32386, x3 + 32385) #axxafterNth s: [1,2] p: 0 w: x1 + x2 + 1 #mark s: [] p: 0 w: 0 #axxtail s: [] p: 0 w: 1 0 s: [] p: 10 w: 5 axxu82 s: [] p: 1 w: max(x1, x2 + 11903) #axxnatsFrom s: [] p: 0 w: 1 axxu81 s: [] p: 12 w: max(x3 + 16492, x4 + 23558) axxisPLNat s: [] p: 3 w: x1 #axxisPLNat s: [] p: 0 w: 0 u11 s: [] p: 2 w: max(x3 + 23560) sel s: [] p: 6 w: x2 + 32387 afterNth s: [2] p: 3 w: max(x2 + 27195) nil s: [] p: 12 w: 5546 #axxsnd s: [] p: 0 w: 0 isLNat s: [] p: 7 w: x1 #axxu21 s: [] p: 0 w: x1 + 1 axxu41 s: [] p: 6 w: max(x1 + 5726, x2 + 6262) axxafterNth s: [2] p: 3 w: max(x2 + 27195) mark s: 1 axxu71 s: [2] p: 11 w: max(x2 + 14297) u101 s: [] p: 0 w: max(x1 + 30653, x3 + 27880) #axxu81 s: [2] p: 1 w: max(x2 + 2583, x3 + 9112, x4 + 9112) axxsel s: [] p: 6 w: x2 + 32387 u21 s: [] p: 4 w: max(x1 + 2, x2 + 1) axxfst s: 1 axxu61 s: [2,1] p: 3 w: max(x1 + 1, x2 + 2) u82 s: [] p: 1 w: max(x1, x2 + 11903) #_ s: [] p: 0 w: x2 + 1 #axxu31 s: [] p: 0 w: 1 #axxsel s: [] p: 0 w: 1 #axxand s: [] p: 0 w: max(x1 + 1) axxu51 s: [1] p: 4 w: max(x1 + 32386, x3 + 32385) head s: 1 cons s: [1] p: 5 w: max(x1, x2) snd s: [1] p: 0 w: x1 + 2 #axxu41 s: [2] p: 0 w: max(x2) axxtail s: [] p: 1 w: x1 + 11601 tt s: [] p: 10 w: 4 u71 s: [2] p: 11 w: max(x2 + 14297) axxtake s: [] p: 1 w: x1 + x2 + 30654 #axxu61 s: [2,1] p: 0 w: x1 + x2 #axxfst s: [] p: 0 w: 0 axxu101 s: [] p: 0 w: max(x1 + 30653, x3 + 27880) #axxu71 s: [1] p: 0 w: x1 #axxisNatural s: [] p: 0 w: 0 u31 s: [2] p: 4 w: max(x1, x2) axxu21 s: [] p: 4 w: max(x1 + 2, x2 + 1) #axxtake s: [2,1] p: 0 w: x1 + x2 #axxhead s: [] p: 0 w: 1 axxhead s: 1 USABLE RULES: { 1..90 } Removed DPs: #89 Number of SCCs: 1, DPs: 19 SCC { #15 #22 #23 #42 #43 #48 #52 #53 #60 #64 #65 #68 #83..85 #103 #114 #115 #123 } POLO(Sum)... POLO(max)... succeeded. u81 w: max(x1 + 4, x2 + 4, x3 + 6, x4 + 3) #axxu51 w: 0 s w: x1 axxisLNat w: 2 u91 w: max(x1 + 3, x2 + 2) #axxu82 w: 0 isPLNat w: 2 axxsnd w: x1 + 3 axxu11 w: max(x2 + 7, x3 + 7) #axxu101 w: 0 #axxisLNat w: 2842 take w: max(x1 + 10786, x2 + 6180) and w: max(x1, x2) axxsplitAt w: max(x1 + 4, x2 + 3) pair w: max(x1, x2 + 3) axxu91 w: max(x1 + 3, x2 + 2) fst w: x1 + 2 axxand w: max(x1, x2) natsFrom w: x1 + 11800 splitAt w: max(x1 + 4, x2 + 3) #axxu11 w: 0 u61 w: max(x1 + 1, x2) axxu31 w: max(x2 + 9516) _ w: 0 isNatural w: 2 #axxsplitAt w: 0 axxnatsFrom w: x1 + 11800 u41 w: max(x1 + 5530, x2 + 11800) axxisNatural w: 2 #axxu91 w: max(x2 + 2841) tail w: x1 + 2 u51 w: max(x1 + 19933, x2 + 19934, x3 + 11819) #axxafterNth w: 0 #mark w: x1 + 2840 #axxtail w: 4 0 w: 8127 axxu82 w: max(x1, x2 + 6) #axxnatsFrom w: x1 + 8373 axxu81 w: max(x1 + 4, x2 + 4, x3 + 6, x4 + 3) axxisPLNat w: 2 #axxisPLNat w: 0 u11 w: max(x2 + 7, x3 + 7) sel w: max(x1 + 19934, x2 + 23192) afterNth w: max(x1 + 8, x2 + 7) nil w: 1 #axxsnd w: 0 isLNat w: 2 #axxu21 w: 0 axxu41 w: max(x1 + 5530, x2 + 11800) axxafterNth w: max(x1 + 8, x2 + 7) mark w: x1 axxu71 w: max(x1 + 3, x2 + 3) u101 w: max(x2 + 7684, x3 + 5) #axxu81 w: 0 axxsel w: max(x1 + 19934, x2 + 23192) u21 w: max(x1 + 1, x2 + 2) axxfst w: x1 + 2 axxu61 w: max(x1 + 1, x2) u82 w: max(x1, x2 + 6) #_ w: 0 #axxu31 w: 0 #axxsel w: 0 #axxand w: max(x1 + 750, x2 + 2840) axxu51 w: max(x1 + 19933, x2 + 19934, x3 + 11819) head w: x1 + 11811 cons w: max(x1 + 3, x2) snd w: x1 + 3 #axxu41 w: max(x1 + 8370, x2 + 2841) axxtail w: x1 + 2 tt w: 1 u71 w: max(x1 + 3, x2 + 3) axxtake w: max(x1 + 10786, x2 + 6180) #axxu61 w: 0 #axxfst w: 0 axxu101 w: max(x2 + 7684, x3 + 5) #axxu71 w: 0 #axxisNatural w: 0 u31 w: max(x2 + 9516) axxu21 w: max(x1 + 1, x2 + 2) #axxtake w: 0 #axxhead w: 2 axxhead w: x1 + 11811 USABLE RULES: { 1..90 } Removed DPs: #15 #22 #23 #42 #48 #52 #53 #64 #65 #83 #85 Number of SCCs: 1, DPs: 7 SCC { #43 #60 #68 #103 #114 #115 #123 } POLO(Sum)... succeeded. u81 w: x1 + 3838 #axxu51 w: 0 s w: x1 + 1 axxisLNat w: 3837 u91 w: 1 #axxu82 w: 1 isPLNat w: 3839 axxsnd w: x1 + 3 axxu11 w: x2 + x3 + 3837 #axxu101 w: 1 #axxisLNat w: x1 + 3840 take w: 3836 and w: x1 + x2 + 9 axxsplitAt w: x2 + 1343 pair w: 3839 axxu91 w: x1 + 1 fst w: 3838 axxand w: 8 natsFrom w: 1102 splitAt w: x1 + x2 + 1344 #axxu11 w: 1 u61 w: 3836 axxu31 w: 3836 _ w: 0 isNatural w: 2238 #axxsplitAt w: 1 axxnatsFrom w: x1 + 1101 u41 w: 1101 axxisNatural w: x1 + 1 #axxu91 w: 3 tail w: 12 u51 w: x2 + 3831 #axxafterNth w: 1 #mark w: x1 + 3 #axxtail w: 0 0 w: 3837 axxu82 w: x2 + 3838 #axxnatsFrom w: 3 axxu81 w: x2 + x3 + x4 + 3837 axxisPLNat w: x1 + 3838 #axxisPLNat w: 1 u11 w: x1 + 3838 sel w: x1 + x2 + 3 afterNth w: x1 + x2 + 5 nil w: 3837 #axxsnd w: 0 isLNat w: x1 + 3838 #axxu21 w: 1 axxu41 w: x1 + 1101 axxafterNth w: 4 mark w: 3836 axxu71 w: x2 + 3837 u101 w: x1 + x2 + 3838 #axxu81 w: 0 axxsel w: 3837 u21 w: 3839 axxfst w: 3837 axxu61 w: x1 + x2 + 3835 u82 w: x1 + 9533 #_ w: 0 #axxu31 w: 0 #axxsel w: 1 #axxand w: x2 + 4 axxu51 w: x1 + x3 + 3830 head w: x1 + 7671 cons w: x1 + x2 + 3 snd w: 4 #axxu41 w: 2 axxtail w: x1 + 11 tt w: 3839 u71 w: x1 + 3838 axxtake w: 3836 #axxu61 w: 1 #axxfst w: 1 axxu101 w: x3 + 3837 #axxu71 w: 1 #axxisNatural w: 1 u31 w: x1 + x2 + 3837 axxu21 w: x2 + 3838 #axxtake w: 1 #axxhead w: 1 axxhead w: 7670 USABLE RULES: { } Removed DPs: #43 #60 #68 #103 #114 #115 #123 Number of SCCs: 0, DPs: 0 >>YES ******** Signature ******** map : ((A -> A),A) -> A nil : A app : ((A -> A),A) -> A ******** Computation rules ******** (91) map(%X.Z25[%X],nil) => nil (92) %Y.G25[%Y]@V25 => G25[V25] ******** General Schema criterion ******** Found constructors: 0, afterNth, and, cons, fst, head, isLNat, isNatural, isPLNat, natsFrom, nil, pair, s, sel, snd, splitAt, tail, take, tt, u101, u11, u21, u31, u41, u51, u61, u71, u81, u82, u91 Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>Regared as equal: mark, axxsel, axxisNatural, axxand Checking (1) axxu101(tt,X,Y) => axxfst(axxsplitAt(mark(X),mark(Y))) (fun axxu101>axxfst) (fun axxu101>axxsplitAt) (fun axxu101>mark) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (fun axxu101>mark) (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu11(tt,U,V) => axxsnd(axxsplitAt(mark(U),mark(V))) (fun axxu11>axxsnd) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (fun axxu11>mark) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu21(tt,W) => mark(W) (fun axxu21>mark) (meta W)[is acc in tt,W] [is positive in tt] [is acc in W] >>True Checking (4) axxu31(tt,P) => mark(P) (fun axxu31>mark) (meta P)[is acc in tt,P] [is positive in tt] [is acc in P] >>True Checking (5) axxu41(tt,X1) => cons(mark(X1),natsFrom(s(X1))) (fun axxu41>cons) (fun axxu41>mark) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] (fun axxu41>natsFrom) (fun axxu41>s) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] >>True Checking (6) axxu51(tt,Y1,U1) => axxhead(axxafterNth(mark(Y1),mark(U1))) (fun axxu51>axxhead) (fun axxu51>axxafterNth) (fun axxu51>mark) (meta Y1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in Y1] (fun axxu51>mark) (meta U1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in U1] >>True Checking (7) axxu61(tt,V1) => mark(V1) (fun axxu61>mark) (meta V1)[is acc in tt,V1] [is positive in tt] [is acc in V1] >>True Checking (8) axxu71(tt,W1) => pair(nil,mark(W1)) (fun axxu71>pair) (fun axxu71>nil) (fun axxu71>mark) (meta W1)[is acc in tt,W1] [is positive in tt] [is acc in W1] >>True Checking (9) axxu81(tt,P1,X2,Y2) => axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) (fun axxu81>axxu82) (fun axxu81>axxsplitAt) (fun axxu81>mark) (meta P1)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in P1] (fun axxu81>mark) (meta Y2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in X2] >>True Checking (10) axxu82(pair(U2,V2),W2) => pair(cons(mark(W2),U2),mark(V2)) (fun axxu82>pair) (fun axxu82>cons) (fun axxu82>mark) (meta W2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in W2] (meta U2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in U2] (fun axxu82>mark) (meta V2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in V2] >>True Checking (11) axxu91(tt,P2) => mark(P2) (fun axxu91>mark) (meta P2)[is acc in tt,P2] [is positive in tt] [is acc in P2] >>True Checking (12) axxafterNth(X3,Y3) => axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) (fun axxafterNth>axxu11) (fun axxafterNth>axxand) (fun axxafterNth>axxisNatural) (meta X3)[is acc in X3,Y3] [is acc in X3] (fun axxafterNth>isLNat) (meta Y3)[is acc in X3,Y3] [is acc in Y3] (meta X3)[is acc in X3,Y3] [is acc in X3] (meta Y3)[is acc in X3,Y3] [is acc in Y3] >>True Checking (13) axxand(tt,U3) => mark(U3) (fun axxand=mark) subterm comparison of args w. LR LR >>False Try again using status RL Checking (1) axxu101(tt,X,Y) => axxfst(axxsplitAt(mark(X),mark(Y))) (fun axxu101>axxfst) (fun axxu101>axxsplitAt) (fun axxu101>mark) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (fun axxu101>mark) (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu11(tt,U,V) => axxsnd(axxsplitAt(mark(U),mark(V))) (fun axxu11>axxsnd) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (fun axxu11>mark) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu21(tt,W) => mark(W) (fun axxu21>mark) (meta W)[is acc in tt,W] [is positive in tt] [is acc in W] >>True Checking (4) axxu31(tt,P) => mark(P) (fun axxu31>mark) (meta P)[is acc in tt,P] [is positive in tt] [is acc in P] >>True Checking (5) axxu41(tt,X1) => cons(mark(X1),natsFrom(s(X1))) (fun axxu41>cons) (fun axxu41>mark) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] (fun axxu41>natsFrom) (fun axxu41>s) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] >>True Checking (6) axxu51(tt,Y1,U1) => axxhead(axxafterNth(mark(Y1),mark(U1))) (fun axxu51>axxhead) (fun axxu51>axxafterNth) (fun axxu51>mark) (meta Y1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in Y1] (fun axxu51>mark) (meta U1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in U1] >>True Checking (7) axxu61(tt,V1) => mark(V1) (fun axxu61>mark) (meta V1)[is acc in tt,V1] [is positive in tt] [is acc in V1] >>True Checking (8) axxu71(tt,W1) => pair(nil,mark(W1)) (fun axxu71>pair) (fun axxu71>nil) (fun axxu71>mark) (meta W1)[is acc in tt,W1] [is positive in tt] [is acc in W1] >>True Checking (9) axxu81(tt,P1,X2,Y2) => axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) (fun axxu81>axxu82) (fun axxu81>axxsplitAt) (fun axxu81>mark) (meta P1)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in P1] (fun axxu81>mark) (meta Y2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in X2] >>True Checking (10) axxu82(pair(U2,V2),W2) => pair(cons(mark(W2),U2),mark(V2)) (fun axxu82>pair) (fun axxu82>cons) (fun axxu82>mark) (meta W2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in W2] (meta U2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in U2] (fun axxu82>mark) (meta V2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in V2] >>True Checking (11) axxu91(tt,P2) => mark(P2) (fun axxu91>mark) (meta P2)[is acc in tt,P2] [is positive in tt] [is acc in P2] >>True Checking (12) axxafterNth(X3,Y3) => axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) (fun axxafterNth>axxu11) (fun axxafterNth>axxand) (fun axxafterNth>axxisNatural) (meta X3)[is acc in X3,Y3] [is acc in X3] (fun axxafterNth>isLNat) (meta Y3)[is acc in X3,Y3] [is acc in Y3] (meta X3)[is acc in X3,Y3] [is acc in X3] (meta Y3)[is acc in X3,Y3] [is acc in Y3] >>True Checking (13) axxand(tt,U3) => mark(U3) (fun axxand=mark) subterm comparison of args w. RL RL >>False Try again using status Mul Checking (1) axxu101(tt,X,Y) => axxfst(axxsplitAt(mark(X),mark(Y))) (fun axxu101>axxfst) (fun axxu101>axxsplitAt) (fun axxu101>mark) (meta X)[is acc in tt,X,Y] [is positive in tt] [is acc in X] (fun axxu101>mark) (meta Y)[is acc in tt,X,Y] [is positive in tt] [is acc in Y] >>True Checking (2) axxu11(tt,U,V) => axxsnd(axxsplitAt(mark(U),mark(V))) (fun axxu11>axxsnd) (fun axxu11>axxsplitAt) (fun axxu11>mark) (meta U)[is acc in tt,U,V] [is positive in tt] [is acc in U] (fun axxu11>mark) (meta V)[is acc in tt,U,V] [is positive in tt] [is acc in V] >>True Checking (3) axxu21(tt,W) => mark(W) (fun axxu21>mark) (meta W)[is acc in tt,W] [is positive in tt] [is acc in W] >>True Checking (4) axxu31(tt,P) => mark(P) (fun axxu31>mark) (meta P)[is acc in tt,P] [is positive in tt] [is acc in P] >>True Checking (5) axxu41(tt,X1) => cons(mark(X1),natsFrom(s(X1))) (fun axxu41>cons) (fun axxu41>mark) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] (fun axxu41>natsFrom) (fun axxu41>s) (meta X1)[is acc in tt,X1] [is positive in tt] [is acc in X1] >>True Checking (6) axxu51(tt,Y1,U1) => axxhead(axxafterNth(mark(Y1),mark(U1))) (fun axxu51>axxhead) (fun axxu51>axxafterNth) (fun axxu51>mark) (meta Y1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in Y1] (fun axxu51>mark) (meta U1)[is acc in tt,Y1,U1] [is positive in tt] [is acc in U1] >>True Checking (7) axxu61(tt,V1) => mark(V1) (fun axxu61>mark) (meta V1)[is acc in tt,V1] [is positive in tt] [is acc in V1] >>True Checking (8) axxu71(tt,W1) => pair(nil,mark(W1)) (fun axxu71>pair) (fun axxu71>nil) (fun axxu71>mark) (meta W1)[is acc in tt,W1] [is positive in tt] [is acc in W1] >>True Checking (9) axxu81(tt,P1,X2,Y2) => axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) (fun axxu81>axxu82) (fun axxu81>axxsplitAt) (fun axxu81>mark) (meta P1)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in P1] (fun axxu81>mark) (meta Y2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in Y2] (meta X2)[is acc in tt,P1,X2,Y2] [is positive in tt] [is acc in X2] >>True Checking (10) axxu82(pair(U2,V2),W2) => pair(cons(mark(W2),U2),mark(V2)) (fun axxu82>pair) (fun axxu82>cons) (fun axxu82>mark) (meta W2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in W2] (meta U2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in U2] (fun axxu82>mark) (meta V2)[is acc in pair(U2,V2),W2] [is positive in pair(U2,V2)] [is acc in V2] >>True Checking (11) axxu91(tt,P2) => mark(P2) (fun axxu91>mark) (meta P2)[is acc in tt,P2] [is positive in tt] [is acc in P2] >>True Checking (12) axxafterNth(X3,Y3) => axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) (fun axxafterNth>axxu11) (fun axxafterNth>axxand) (fun axxafterNth>axxisNatural) (meta X3)[is acc in X3,Y3] [is acc in X3] (fun axxafterNth>isLNat) (meta Y3)[is acc in X3,Y3] [is acc in Y3] (meta X3)[is acc in X3,Y3] [is acc in X3] (meta Y3)[is acc in X3,Y3] [is acc in Y3] >>True Checking (13) axxand(tt,U3) => mark(U3) (fun axxand=mark) subterm comparison of args w. Mul Mul (meta U3)[is acc in tt,U3] [is positive in tt] [is acc in U3] >>True Checking (14) axxfst(pair(V3,W3)) => axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) (fun axxfst>axxu21) (fun axxfst>axxand) (fun axxfst>axxisLNat) (meta V3)[is acc in pair(V3,W3)] [is positive in pair(V3,W3)] [is acc in V3] (fun axxfst>isLNat) (meta W3)[is acc in pair(V3,W3)] [is positive in pair(V3,W3)] [is acc in W3] (meta V3)[is acc in pair(V3,W3)] [is positive in pair(V3,W3)] [is acc in V3] >>True Checking (15) axxhead(cons(P3,X4)) => axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) (fun axxhead>axxu31) (fun axxhead>axxand) (fun axxhead>axxisNatural) (meta P3)[is acc in cons(P3,X4)] [is positive in cons(P3,X4)] [is acc in P3] (fun axxhead>isLNat) (meta X4)[is acc in cons(P3,X4)] [is positive in cons(P3,X4)] [is acc in X4] (meta P3)[is acc in cons(P3,X4)] [is positive in cons(P3,X4)] [is acc in P3] >>True Checking (16) axxisLNat(nil) => tt (fun axxisLNat>tt) >>True Checking (17) axxisLNat(afterNth(Y4,U4)) => axxand(axxisNatural(Y4),isLNat(U4)) (fun axxisLNat>axxand) (fun axxisLNat>axxisNatural) (meta Y4)[is acc in afterNth(Y4,U4)] [is positive in afterNth(Y4,U4)] [is acc in Y4] (fun axxisLNat>isLNat) (meta U4)[is acc in afterNth(Y4,U4)] [is positive in afterNth(Y4,U4)] [is acc in U4] >>True Checking (18) axxisLNat(cons(V4,W4)) => axxand(axxisNatural(V4),isLNat(W4)) (fun axxisLNat>axxand) (fun axxisLNat>axxisNatural) (meta V4)[is acc in cons(V4,W4)] [is positive in cons(V4,W4)] [is acc in V4] (fun axxisLNat>isLNat) (meta W4)[is acc in cons(V4,W4)] [is positive in cons(V4,W4)] [is acc in W4] >>True Checking (19) axxisLNat(fst(P4)) => axxisPLNat(P4) (fun axxisLNat>axxisPLNat) (meta P4)[is acc in fst(P4)] [is positive in fst(P4)] [is acc in P4] >>True Checking (20) axxisLNat(natsFrom(X5)) => axxisNatural(X5) (fun axxisLNat>axxisNatural) (meta X5)[is acc in natsFrom(X5)] [is positive in natsFrom(X5)] [is acc in X5] >>True Checking (21) axxisLNat(snd(Y5)) => axxisPLNat(Y5) (fun axxisLNat>axxisPLNat) (meta Y5)[is acc in snd(Y5)] [is positive in snd(Y5)] [is acc in Y5] >>True Checking (22) axxisLNat(tail(U5)) => axxisLNat(U5) (fun axxisLNat=axxisLNat) subterm comparison of args w. Mul Mul (meta U5)[is acc in tail(U5)] [is positive in tail(U5)] [is acc in U5] >>True Checking (23) axxisLNat(take(V5,W5)) => axxand(axxisNatural(V5),isLNat(W5)) (fun axxisLNat>axxand) (fun axxisLNat>axxisNatural) (meta V5)[is acc in take(V5,W5)] [is positive in take(V5,W5)] [is acc in V5] (fun axxisLNat>isLNat) (meta W5)[is acc in take(V5,W5)] [is positive in take(V5,W5)] [is acc in W5] >>True Checking (24) axxisNatural(0) => tt (fun axxisNatural>tt) >>True Checking (25) axxisNatural(head(P5)) => axxisLNat(P5) (fun axxisNatural>axxisLNat) (meta P5)[is acc in head(P5)] [is positive in head(P5)] [is acc in P5] >>True Checking (26) axxisNatural(s(X6)) => axxisNatural(X6) (fun axxisNatural=axxisNatural) subterm comparison of args w. Mul Mul (meta X6)[is acc in s(X6)] [is positive in s(X6)] [is acc in X6] >>True Checking (27) axxisNatural(sel(Y6,U6)) => axxand(axxisNatural(Y6),isLNat(U6)) (fun axxisNatural=axxand) subterm comparison of args w. Mul Mul >>False Found constructors: nil Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>OK Checking (91) map(%X.Z25[%X],nil) => nil (fun map>nil) >>True Checking (92) %Y.G25[%Y]@V25 => G25[V25] (meta G25)[is acc in %Y.G25[%Y],V25] [is acc in G25[%Y]] (meta V25)[is acc in %Y.G25[%Y],V25] [is acc in V25] >>True #SN! ******** Signature ******** 0 : A afterNth : (A,A) -> A and : (A,A) -> A app : ((A -> A),A) -> A axxafterNth : (A,A) -> A axxand : (A,A) -> A axxfst : A -> A axxhead : A -> A axxisLNat : A -> A axxisNatural : A -> A axxisPLNat : A -> A axxnatsFrom : A -> A axxsel : (A,A) -> A axxsnd : A -> A axxsplitAt : (A,A) -> A axxtail : A -> A axxtake : (A,A) -> A axxu101 : (A,A,A) -> A axxu11 : (A,A,A) -> A axxu21 : (A,A) -> A axxu31 : (A,A) -> A axxu41 : (A,A) -> A axxu51 : (A,A,A) -> A axxu61 : (A,A) -> A axxu71 : (A,A) -> A axxu81 : (A,A,A,A) -> A axxu82 : (A,A) -> A axxu91 : (A,A) -> A cons : (A,A) -> A fst : A -> A head : A -> A isLNat : A -> A isNatural : A -> A isPLNat : A -> A map : ((A -> A),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 u101 : (A,A,A) -> A u11 : (A,A,A) -> A u21 : (A,A) -> A u31 : (A,A) -> A u41 : (A,A) -> A u51 : (A,A,A) -> A u61 : (A,A) -> A u71 : (A,A) -> A u81 : (A,A,A,A) -> A u82 : (A,A) -> A u91 : (A,A) -> A ******** Computation Rules ******** (1) axxu101(tt,X,Y) => axxfst(axxsplitAt(mark(X),mark(Y))) (2) axxu11(tt,U,V) => axxsnd(axxsplitAt(mark(U),mark(V))) (3) axxu21(tt,W) => mark(W) (4) axxu31(tt,P) => mark(P) (5) axxu41(tt,X1) => cons(mark(X1),natsFrom(s(X1))) (6) axxu51(tt,Y1,U1) => axxhead(axxafterNth(mark(Y1),mark(U1))) (7) axxu61(tt,V1) => mark(V1) (8) axxu71(tt,W1) => pair(nil,mark(W1)) (9) axxu81(tt,P1,X2,Y2) => axxu82(axxsplitAt(mark(P1),mark(Y2)),X2) (10) axxu82(pair(U2,V2),W2) => pair(cons(mark(W2),U2),mark(V2)) (11) axxu91(tt,P2) => mark(P2) (12) axxafterNth(X3,Y3) => axxu11(axxand(axxisNatural(X3),isLNat(Y3)),X3,Y3) (13) axxand(tt,U3) => mark(U3) (14) axxfst(pair(V3,W3)) => axxu21(axxand(axxisLNat(V3),isLNat(W3)),V3) (15) axxhead(cons(P3,X4)) => axxu31(axxand(axxisNatural(P3),isLNat(X4)),P3) (16) axxisLNat(nil) => tt (17) axxisLNat(afterNth(Y4,U4)) => axxand(axxisNatural(Y4),isLNat(U4)) (18) axxisLNat(cons(V4,W4)) => axxand(axxisNatural(V4),isLNat(W4)) (19) axxisLNat(fst(P4)) => axxisPLNat(P4) (20) axxisLNat(natsFrom(X5)) => axxisNatural(X5) (21) axxisLNat(snd(Y5)) => axxisPLNat(Y5) (22) axxisLNat(tail(U5)) => axxisLNat(U5) (23) axxisLNat(take(V5,W5)) => axxand(axxisNatural(V5),isLNat(W5)) (24) axxisNatural(0) => tt (25) axxisNatural(head(P5)) => axxisLNat(P5) (26) axxisNatural(s(X6)) => axxisNatural(X6) (27) axxisNatural(sel(Y6,U6)) => axxand(axxisNatural(Y6),isLNat(U6)) (28) axxisPLNat(pair(V6,W6)) => axxand(axxisLNat(V6),isLNat(W6)) (29) axxisPLNat(splitAt(P6,X7)) => axxand(axxisNatural(P6),isLNat(X7)) (30) axxnatsFrom(Y7) => axxu41(axxisNatural(Y7),Y7) (31) axxsel(U7,V7) => axxu51(axxand(axxisNatural(U7),isLNat(V7)),U7,V7) (32) axxsnd(pair(W7,P7)) => axxu61(axxand(axxisLNat(W7),isLNat(P7)),P7) (33) axxsplitAt(0,X8) => axxu71(axxisLNat(X8),X8) (34) axxsplitAt(s(Y8),cons(U8,V8)) => axxu81(axxand(axxisNatural(Y8),and(isNatural(U8),isLNat(V8))),Y8,U8,V8) (35) axxtail(cons(W8,P8)) => axxu91(axxand(axxisNatural(W8),isLNat(P8)),P8) (36) axxtake(X9,Y9) => axxu101(axxand(axxisNatural(X9),isLNat(Y9)),X9,Y9) (37) mark(u101(U9,V9,W9)) => axxu101(mark(U9),V9,W9) (38) mark(fst(P9)) => axxfst(mark(P9)) (39) mark(splitAt(X10,Y10)) => axxsplitAt(mark(X10),mark(Y10)) (40) mark(u11(U10,V10,W10)) => axxu11(mark(U10),V10,W10) (41) mark(snd(P10)) => axxsnd(mark(P10)) (42) mark(u21(X11,Y11)) => axxu21(mark(X11),Y11) (43) mark(u31(U11,V11)) => axxu31(mark(U11),V11) (44) mark(u41(W11,P11)) => axxu41(mark(W11),P11) (45) mark(natsFrom(X12)) => axxnatsFrom(mark(X12)) (46) mark(u51(Y12,U12,V12)) => axxu51(mark(Y12),U12,V12) (47) mark(head(W12)) => axxhead(mark(W12)) (48) mark(afterNth(P12,X13)) => axxafterNth(mark(P12),mark(X13)) (49) mark(u61(Y13,U13)) => axxu61(mark(Y13),U13) (50) mark(u71(V13,W13)) => axxu71(mark(V13),W13) (51) mark(u81(P13,X14,Y14,U14)) => axxu81(mark(P13),X14,Y14,U14) (52) mark(u82(V14,W14)) => axxu82(mark(V14),W14) (53) mark(u91(P14,X15)) => axxu91(mark(P14),X15) (54) mark(and(Y15,U15)) => axxand(mark(Y15),U15) (55) mark(isNatural(V15)) => axxisNatural(V15) (56) mark(isLNat(W15)) => axxisLNat(W15) (57) mark(isPLNat(P15)) => axxisPLNat(P15) (58) mark(tail(X16)) => axxtail(mark(X16)) (59) mark(take(Y16,U16)) => axxtake(mark(Y16),mark(U16)) (60) mark(sel(V16,W16)) => axxsel(mark(V16),mark(W16)) (61) mark(tt) => tt (62) mark(cons(P16,X17)) => cons(mark(P16),X17) (63) mark(s(Y17)) => s(mark(Y17)) (64) mark(pair(U17,V17)) => pair(mark(U17),mark(V17)) (65) mark(nil) => nil (66) mark(0) => 0 (67) axxu101(W17,P17,X18) => u101(W17,P17,X18) (68) axxfst(Y18) => fst(Y18) (69) axxsplitAt(U18,V18) => splitAt(U18,V18) (70) axxu11(W18,P18,X19) => u11(W18,P18,X19) (71) axxsnd(Y19) => snd(Y19) (72) axxu21(U19,V19) => u21(U19,V19) (73) axxu31(W19,P19) => u31(W19,P19) (74) axxu41(X20,Y20) => u41(X20,Y20) (75) axxnatsFrom(U20) => natsFrom(U20) (76) axxu51(V20,W20,P20) => u51(V20,W20,P20) (77) axxhead(X21) => head(X21) (78) axxafterNth(Y21,U21) => afterNth(Y21,U21) (79) axxu61(V21,W21) => u61(V21,W21) (80) axxu71(P21,X22) => u71(P21,X22) (81) axxu81(Y22,U22,V22,W22) => u81(Y22,U22,V22,W22) (82) axxu82(P22,X23) => u82(P22,X23) (83) axxu91(Y23,U23) => u91(Y23,U23) (84) axxand(V23,W23) => and(V23,W23) (85) axxisNatural(P23) => isNatural(P23) (86) axxisLNat(X24) => isLNat(X24) (87) axxisPLNat(Y24) => isPLNat(Y24) (88) axxtail(U24) => tail(U24) (89) axxtake(V24,W24) => take(V24,W24) (90) axxsel(P24,X25) => sel(P24,X25) (91) map(%X.Z25[%X],nil) => nil (92) %Y.G25[%Y]@V25 => G25[V25] YES