/export/starexec/sandbox2/solver/bin/starexec_run_hrs /export/starexec/sandbox2/benchmark/theBenchmark.xml /export/starexec/sandbox2/output/output_files -------------------------------------------------------------------------------- MAYBE 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: neq(0(),0()) -> false() 2: neq(0(),s(X)) -> true() 3: neq(s(Y),0()) -> true() 4: neq(s(U),s(V)) -> neq(U,V) 5: _(X1,X2) -> X1 6: _(X1,X2) -> X2 Number of strict rules: 6 Direct POLO(bPol) ... removes: 4 1 3 5 6 2 neq w: 2 * x1 + 2 * x2 s w: 2 * x1 + 1 false w: 9131 _ w: 2 * x1 + 2 * x2 + 1 true w: 4567 0 w: 2283 Number of strict rules: 0 ... Input TRS: 1: neq(0(),0()) -> false() 2: neq(0(),s(X)) -> true() 3: neq(s(Y),0()) -> true() 4: neq(s(U),s(V)) -> neq(U,V) 5: _(X1,X2) -> X1 6: _(X1,X2) -> X2 Number of strict rules: 6 Direct POLO(bPol) ... removes: 4 1 3 5 6 2 neq w: 2 * x1 + 2 * x2 s w: 2 * x1 + 1 false w: 9131 _ w: 2 * x1 + 2 * x2 + 1 true w: 4567 0 w: 2283 Number of strict rules: 0 >>YES ******** Signature ******** filter : ((a -> b),c) -> c nil : c cons : (a,c) -> c filtersub : (b,(a -> b),c) -> c true : b false : b nonzero : c -> c neq : (a,a) -> b 0 : a ******** Computation rules ******** (5) filter(I,nil) => nil (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (7) filtersub(true,G1,cons(V1,W1)) => cons(V1,filter(G1,W1)) (8) filtersub(false,J1,cons(X2,Y2)) => filter(J1,Y2) (9) nonzero => filter(neq(0)) ******** General Schema criterion ******** Found constructors: 0, cons, false, nil, s, true Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>Regared as equal: nonzero, filter, filtersub Checking (1) neq(0,0) => false (fun neq>false) >>True Checking (2) neq(0,s(X)) => true (fun neq>true) >>True Checking (3) neq(s(Y),0) => true (fun neq>true) >>True Checking (4) neq(s(U),s(V)) => neq(U,V) (fun neq=neq) subterm comparison of args w. LR LR (meta U)[is acc in s(U),s(V)] [is positive in s(U)] [is acc in U] (meta V)[is acc in s(U),s(V)] [is positive in s(U)] [is positive in s(V)] [is acc in V] >>True Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False Try again using status RL Checking (1) neq(0,0) => false (fun neq>false) >>True Checking (2) neq(0,s(X)) => true (fun neq>true) >>True Checking (3) neq(s(Y),0) => true (fun neq>true) >>True Checking (4) neq(s(U),s(V)) => neq(U,V) (fun neq=neq) subterm comparison of args w. RL RL (meta U)[is acc in s(U),s(V)] [is positive in s(U)] [is acc in U] (meta V)[is acc in s(U),s(V)] [is positive in s(U)] [is positive in s(V)] [is acc in V] >>True Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False Try again using status Mul Checking (1) neq(0,0) => false (fun neq>false) >>True Checking (2) neq(0,s(X)) => true (fun neq>true) >>True Checking (3) neq(s(Y),0) => true (fun neq>true) >>True Checking (4) neq(s(U),s(V)) => neq(U,V) (fun neq=neq) subterm comparison of args w. Mul Mul (meta U)[is acc in s(U),s(V)] [is positive in s(U)] [is acc in U] (meta V)[is acc in s(U),s(V)] [is positive in s(U)] [is positive in s(V)] [is acc in V] >>True Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False Found constructors: nil, cons, true, false, neq, 0 Checking type order >>OK Checking positivity of constructors >>OK Checking function dependency >>Regared as equal: nonzero, filter, filtersub Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False Try again using status RL Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False Try again using status Mul Checking (5) filter(I,nil) => nil (fun filter>nil) >>True Checking (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (fun filter=filtersub) subterm comparison of args w. Arg [1,2] Arg [2,3,1] >>False #No idea.. ******** Signature ******** 0 : a cons : (a,c) -> c false : b filter : ((a -> b),c) -> c filtersub : (b,(a -> b),c) -> c neq : (a,a) -> b nil : c nonzero : c -> c s : a -> a true : b ******** Computation Rules ******** (1) neq(0,0) => false (2) neq(0,s(X)) => true (3) neq(s(Y),0) => true (4) neq(s(U),s(V)) => neq(U,V) (5) filter(I,nil) => nil (6) filter(J,cons(X1,Y1)) => filtersub(J[X1],J,cons(X1,Y1)) (7) filtersub(true,G1,cons(V1,W1)) => cons(V1,filter(G1,W1)) (8) filtersub(false,J1,cons(X2,Y2)) => filter(J1,Y2) (9) nonzero => filter(neq(0)) MAYBE