/export/starexec/sandbox/solver/bin/starexec_run_default /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


--------------------------------------------------------------------------------


YES

Using the interpretation [[filtersub]](B,J,cons(X1,Y1)) = ifo(B,cons(X1,filter(J,Y1)),filter(J,Y1))
given system is strictly simulated by
 (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
 (6if)  filter(J,cons(X1,Y1)) => ifo(J[X1],cons(X1,filter(J,Y1)),filter(J,Y1))
 (9)  nonzero => filter(neq(0))
 (ift)  ifo(true,T,E) => T
 (iff)  ifo(false,T,E) => E

Hene we try to show SN of this.
******** 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
Found constructors: 0, cons, false, filtersub, nil, s, true
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
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  (6if) filter(J,cons(X1,Y1)) => ifo(J[X1],cons(X1,filter(J,Y1)),filter(J,Y1))
 (fun filter>ifo)
 (meta J)[is acc in J,cons(X1,Y1)] [is acc in J] 
 (meta X1)[is acc in J,cons(X1,Y1)] [is positive in cons(X1,Y1)] [is acc in X1] 
 (fun filter>cons)
 (meta X1)[is acc in J,cons(X1,Y1)] [is positive in cons(X1,Y1)] [is acc in X1] 
 (fun filter=filter) subterm comparison of args w. Arg [1,2] Arg [1,2]
 (meta J)[is acc in J,cons(X1,Y1)] [is acc in J] 
 (meta Y1)[is acc in J,cons(X1,Y1)] [is positive in cons(X1,Y1)] [is acc in Y1] 
 (fun filter=filter) subterm comparison of args w. Arg [1,2] Arg [1,2]
 (meta J)[is acc in J,cons(X1,Y1)] [is acc in J] 
 (meta Y1)[is acc in J,cons(X1,Y1)] [is positive in cons(X1,Y1)] [is acc in Y1]  >>True
Checking  (9) nonzero => filter(neq(0))
 (fun nonzero>filter)
 (fun nonzero>neq)
 (fun nonzero>0) >>True
Checking  (ift) ifo(true,T,E) => T
 (meta T)[is acc in true,T,E] [is positive in true] [is acc in T]  >>True
Checking  (iff) ifo(false,T,E) => E
 (meta E)[is acc in false,T,E] [is positive in false] [is acc in E]  >>True
#SN!
******** 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))

YES