/export/starexec/sandbox2/solver/bin/starexec_run_Default /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- NO Input TRS: 1: and(tt(),T) -> T 2: isNatIList(IL) -> isNatList(activate(IL)) 3: isNat(n__0()) -> tt() 4: isNat(n__s(N)) -> isNat(activate(N)) 5: isNat(n__length(L)) -> isNatList(activate(L)) 6: isNatIList(n__zeros()) -> tt() 7: isNatIList(n__cons(N,IL)) -> and(isNat(activate(N)),isNatIList(activate(IL))) 8: isNatList(n__nil()) -> tt() 9: isNatList(n__cons(N,L)) -> and(isNat(activate(N)),isNatList(activate(L))) 10: isNatList(n__take(N,IL)) -> and(isNat(activate(N)),isNatIList(activate(IL))) 11: zeros() -> cons(0(),n__zeros()) 12: take(0(),IL) -> uTake1(isNatIList(IL)) 13: uTake1(tt()) -> nil() 14: take(s(M),cons(N,IL)) -> uTake2(and(isNat(M),and(isNat(N),isNatIList(activate(IL)))),M,N,activate(IL)) 15: uTake2(tt(),M,N,IL) -> cons(activate(N),n__take(activate(M),activate(IL))) 16: length(cons(N,L)) -> uLength(and(isNat(N),isNatList(activate(L))),activate(L)) 17: uLength(tt(),L) -> s(length(activate(L))) 18: 0() -> n__0() 19: s(X) -> n__s(X) 20: length(X) -> n__length(X) 21: zeros() -> n__zeros() 22: cons(X1,X2) -> n__cons(X1,X2) 23: nil() -> n__nil() 24: take(X1,X2) -> n__take(X1,X2) 25: activate(n__0()) -> 0() 26: activate(n__s(X)) -> s(activate(X)) 27: activate(n__length(X)) -> length(activate(X)) 28: activate(n__zeros()) -> zeros() 29: activate(n__cons(X1,X2)) -> cons(activate(X1),X2) 30: activate(n__nil()) -> nil() 31: activate(n__take(X1,X2)) -> take(activate(X1),activate(X2)) 32: activate(X) -> X Number of strict rules: 32 Direct POLO(bPol) ... failed. Uncurrying ... failed. Dependency Pairs: #1: #isNatIList(IL) -> #isNatList(activate(IL)) #2: #isNatIList(IL) -> #activate(IL) #3: #activate(n__cons(X1,X2)) -> #cons(activate(X1),X2) #4: #activate(n__cons(X1,X2)) -> #activate(X1) #5: #uTake1(tt()) -> #nil() #6: #isNatList(n__cons(N,L)) -> #and(isNat(activate(N)),isNatList(activate(L))) #7: #isNatList(n__cons(N,L)) -> #isNat(activate(N)) #8: #isNatList(n__cons(N,L)) -> #activate(N) #9: #isNatList(n__cons(N,L)) -> #isNatList(activate(L)) #10: #isNatList(n__cons(N,L)) -> #activate(L) #11: #zeros() -> #cons(0(),n__zeros()) #12: #zeros() -> #0() #13: #take(0(),IL) -> #uTake1(isNatIList(IL)) #14: #take(0(),IL) -> #isNatIList(IL) #15: #activate(n__take(X1,X2)) -> #take(activate(X1),activate(X2)) #16: #activate(n__take(X1,X2)) -> #activate(X1) #17: #activate(n__take(X1,X2)) -> #activate(X2) #18: #take(s(M),cons(N,IL)) -> #uTake2(and(isNat(M),and(isNat(N),isNatIList(activate(IL)))),M,N,activate(IL)) #19: #take(s(M),cons(N,IL)) -> #and(isNat(M),and(isNat(N),isNatIList(activate(IL)))) #20: #take(s(M),cons(N,IL)) -> #isNat(M) #21: #take(s(M),cons(N,IL)) -> #and(isNat(N),isNatIList(activate(IL))) #22: #take(s(M),cons(N,IL)) -> #isNat(N) #23: #take(s(M),cons(N,IL)) -> #isNatIList(activate(IL)) #24: #take(s(M),cons(N,IL)) -> #activate(IL) #25: #take(s(M),cons(N,IL)) -> #activate(IL) #26: #activate(n__nil()) -> #nil() #27: #activate(n__0()) -> #0() #28: #isNatIList(n__cons(N,IL)) -> #and(isNat(activate(N)),isNatIList(activate(IL))) #29: #isNatIList(n__cons(N,IL)) -> #isNat(activate(N)) #30: #isNatIList(n__cons(N,IL)) -> #activate(N) #31: #isNatIList(n__cons(N,IL)) -> #isNatIList(activate(IL)) #32: #isNatIList(n__cons(N,IL)) -> #activate(IL) #33: #isNatList(n__take(N,IL)) -> #and(isNat(activate(N)),isNatIList(activate(IL))) #34: #isNatList(n__take(N,IL)) -> #isNat(activate(N)) #35: #isNatList(n__take(N,IL)) -> #activate(N) #36: #isNatList(n__take(N,IL)) -> #isNatIList(activate(IL)) #37: #isNatList(n__take(N,IL)) -> #activate(IL) #38: #isNat(n__length(L)) -> #isNatList(activate(L)) #39: #isNat(n__length(L)) -> #activate(L) #40: #activate(n__zeros()) -> #zeros() #41: #activate(n__length(X)) -> #length(activate(X)) #42: #activate(n__length(X)) -> #activate(X) #43: #uLength(tt(),L) -> #s(length(activate(L))) #44: #uLength(tt(),L) -> #length(activate(L)) #45: #uLength(tt(),L) -> #activate(L) #46: #activate(n__s(X)) -> #s(activate(X)) #47: #activate(n__s(X)) -> #activate(X) #48: #length(cons(N,L)) -> #uLength(and(isNat(N),isNatList(activate(L))),activate(L)) #49: #length(cons(N,L)) -> #and(isNat(N),isNatList(activate(L))) #50: #length(cons(N,L)) -> #isNat(N) #51: #length(cons(N,L)) -> #isNatList(activate(L)) #52: #length(cons(N,L)) -> #activate(L) #53: #length(cons(N,L)) -> #activate(L) #54: #uTake2(tt(),M,N,IL) -> #cons(activate(N),n__take(activate(M),activate(IL))) #55: #uTake2(tt(),M,N,IL) -> #activate(N) #56: #uTake2(tt(),M,N,IL) -> #activate(M) #57: #uTake2(tt(),M,N,IL) -> #activate(IL) #58: #isNat(n__s(N)) -> #isNat(activate(N)) #59: #isNat(n__s(N)) -> #activate(N) Number of SCCs: 1, DPs: 42 SCC { #1 #2 #4 #7..10 #14..18 #20 #22..25 #29..32 #34..39 #41 #42 #44 #45 #47 #48 #50..53 #55..59 } POLO(Sum)... succeeded. #uTake2 w: x2 + x3 + x4 #0 w: 0 isNatList w: 2 #cons w: 0 s w: x1 #isNat w: x1 #take w: x1 + x2 activate w: x1 take w: x1 + x2 #uTake1 w: 0 and w: x1 + 3 n__zeros w: 1 isNatIList w: 1 #activate w: x1 zeros w: 1 n__nil w: 0 uTake2 w: x2 + x3 + x4 n__s w: x1 uLength w: x2 + 2 0 w: 0 #zeros w: 0 n__take w: x1 + x2 #isNatList w: x1 #s w: 0 n__cons w: x1 + x2 nil w: 0 #nil w: 0 n__0 w: 0 n__length w: x1 + 2 isNat w: x1 cons w: x1 + x2 #isNatIList w: x1 tt w: 3 uTake1 w: 0 length w: x1 + 2 #length w: x1 + 1 #and w: 0 #uLength w: x2 + 1 USABLE RULES: { 11..32 } Removed DPs: #38 #39 #41 #42 #45 #50..53 Number of SCCs: 2, DPs: 33 SCC { #44 #48 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... Mat2b... succeeded. #uTake2 w: [0;0] #0 w: [0;0] isNatList w: [0,1;1,1] * x1 + [0;2] #cons w: [0;0] s w: [0,0;1,1] * x1 + [2;0] #isNat w: [0;0] #take w: [0;0] activate w: x1 take w: [1,1;0,0] * x1 + x2 + [1;2] #uTake1 w: [0;0] and w: x2 n__zeros w: [1;0] isNatIList w: [0,1;1,1] * x1 + [2;2] #activate w: [0;0] zeros w: [1;0] n__nil w: [3;2] uTake2 w: [1,1;0,0] * x2 + [1,1;0,1] * x4 + [3;2] n__s w: [0,0;1,1] * x1 + [2;0] uLength w: [1,0;0,0] * x1 + [0,0;1,1] * x2 + [0;1] 0 w: [1;1] #zeros w: [0;0] n__take w: [1,1;0,0] * x1 + x2 + [1;2] #isNatList w: [0;0] #s w: [0;0] n__cons w: [1,1;0,1] * x2 nil w: [3;2] #nil w: [0;0] n__0 w: [1;1] n__length w: [0,1;1,0] * x1 + [0;1] isNat w: [0,1;0,0] * x1 + [1;1] cons w: [1,1;0,1] * x2 #isNatIList w: [0;0] tt w: [2;1] uTake1 w: [3;2] length w: [0,1;1,0] * x1 + [0;1] #length w: [1,0;1,1] * x1 + [4;0] #and w: [0;0] #uLength w: [1,0;1,0] * x1 + [1,0;1,1] * x2 + [3;0] USABLE RULES: { 1 2 6..32 } Removed DPs: #44 #48 Number of SCCs: 1, DPs: 31 SCC { #1 #2 #4 #7..10 #14..18 #20 #22..25 #29..32 #34..37 #47 #55..59 } POLO(Sum)... succeeded. #uTake2 w: x2 + x3 + x4 + 1 #0 w: 0 isNatList w: 2 #cons w: 0 s w: x1 #isNat w: x1 + 1 #take w: x1 + x2 + 4 activate w: x1 take w: x1 + x2 + 5 #uTake1 w: 0 and w: x1 n__zeros w: 1 isNatIList w: 1 #activate w: x1 zeros w: 1 n__nil w: 5 uTake2 w: x2 + x3 + x4 + 5 n__s w: x1 uLength w: 2 0 w: 0 #zeros w: 0 n__take w: x1 + x2 + 5 #isNatList w: x1 + 2 #s w: 0 n__cons w: x1 + x2 nil w: 5 #nil w: 0 n__0 w: 0 n__length w: 2 isNat w: 2 cons w: x1 + x2 #isNatIList w: x1 + 3 tt w: 3 uTake1 w: 5 length w: 2 #length w: 5 #and w: 0 #uLength w: 3 USABLE RULES: { 11..32 } Removed DPs: #1 #2 #7 #8 #10 #14..18 #20 #22..25 #29 #30 #32 #34..37 #55..57 #59 Number of SCCs: 4, DPs: 5 SCC { #58 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... Mat2b... succeeded. #uTake2 w: [0;0] #0 w: [0;0] isNatList w: [1,1;0,1] * x1 + [1;1] #cons w: [0;0] s w: [0,0;0,1] * x1 + [0;1] #isNat w: [0,1;0,0] * x1 #take w: [0;0] activate w: x1 take w: [0,1;0,0] * x1 + x2 + [1;1] #uTake1 w: [0;0] and w: x2 n__zeros w: [1;0] isNatIList w: [1,1;0,1] * x1 + [1;2] #activate w: [0;0] zeros w: [1;0] n__nil w: [1;1] uTake2 w: [0,1;0,0] * x2 + [1,1;0,1] * x4 + [2;1] n__s w: [0,0;0,1] * x1 + [0;1] uLength w: [0,0;0,1] * x1 + [1,1;1,0] * x2 0 w: [1;1] #zeros w: [0;0] n__take w: [0,1;0,0] * x1 + x2 + [1;1] #isNatList w: [0;0] #s w: [0;0] n__cons w: [1,1;0,1] * x2 nil w: [1;1] #nil w: [0;0] n__0 w: [1;1] n__length w: [1,1;1,0] * x1 + [0;1] isNat w: [1,0;1,1] * x1 + [1;1] cons w: [1,1;0,1] * x2 #isNatIList w: [0;0] tt w: [1;2] uTake1 w: [1;1] length w: [1,1;1,0] * x1 + [0;1] #length w: [4;0] #and w: [0;0] #uLength w: [3;0] USABLE RULES: { 1 2 6..32 } Removed DPs: #58 Number of SCCs: 3, DPs: 4 SCC { #31 } POLO(Sum)... POLO(max)... QLPOS... POLO(mSum)... QWPOpS(mSum)... Mat2b... failed. Finding a loop... found. #isNatIList(n__cons(N,n__zeros())) -#31-> #isNatIList(activate(n__zeros())) --->* #isNatIList(n__cons(0(),n__zeros())) Looping with: [ N := 0(); ]