/export/starexec/sandbox/solver/bin/starexec_run_hrs /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/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: app(nil(),X) -> X
    2: app(cons(Y,U),V) -> cons(Y,app(U,V))
    3: iconsc(W1,P1) -> cons(P1,W1)
    4: _(X1,X2) -> X1
    5: _(X1,X2) -> X2
Number of strict rules: 5
Direct POLO(bPol) ... removes: 4 1 3 5 2
      _ 	w: 2 * x1 + 2 * x2 + 1
      nil	w: 1
      iconsc	w: x1 + x2 + 8857
      cons	w: x1 + x2 + 8856
      app	w: 2 * x1 + x2 + 2438
Number of strict rules: 0

...
Input TRS:
    1: app(nil(),X) -> X
    2: app(cons(Y,U),V) -> cons(Y,app(U,V))
    3: iconsc(W1,P1) -> cons(P1,W1)
    4: _(X1,X2) -> X1
    5: _(X1,X2) -> X2
Number of strict rules: 5
Direct POLO(bPol) ... removes: 4 1 3 5 2
      _ 	w: 2 * x1 + 2 * x2 + 1
      nil	w: 1
      iconsc	w: x1 + x2 + 8857
      cons	w: x1 + x2 + 8856
      app	w: 2 * x1 + x2 + 2438
Number of strict rules: 0
>>YES

******** Signature ********
 foldl : (((list,nat) -> list),list,list) -> list
 yap : ((nat -> list),nat) -> list
 xap : (((list,nat) -> list),list,nat) -> list
 nil : list
 cons : (nat,list) -> list
 reverse : list -> list
 iconsc : (list,nat) -> list
 reverse1 : list -> list
 app : (list,list) -> list
******** Computation rules ********
 (3)  foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (4)  foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (6)  reverse(X2) => foldl(%F.%G.yap(xap(iconsc,%F),%G),nil,X2)
 (7)  reverse1(Y2) => foldl(%I.%H.(cons(%H,nil)@%I),nil,Y2)
 (8)  xap(G2,V2) => G2[V2]
 (9)  yap(I2,P2) => I2[P2]


******** General Schema criterion ********
Found constructors: cons, nil
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (1) nil@X => X
 (meta X)[is acc in nil,X] [is positive in nil] [is acc in X]  >>True
Checking  (2) cons(Y,U)@V => cons(Y,U@V)
 (fun app>cons)
 (meta Y)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in Y] 
 (fun app=app) subterm comparison of args w. LR LR
 (meta U)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in U] 
 (meta V)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in V]  >>True
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (1) nil@X => X
 (meta X)[is acc in nil,X] [is positive in nil] [is acc in X]  >>True
Checking  (2) cons(Y,U)@V => cons(Y,U@V)
 (fun app>cons)
 (meta Y)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in Y] 
 (fun app=app) subterm comparison of args w. RL RL
 (meta U)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in U] 
 (meta V)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in V]  >>True
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. RL RL
 (fun foldl>yap)
 (fun foldl>xap)
 (meta F1)[is acc in %Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)] [is positive in yap(xap(F1,%Z),%U)] [is positive in xap(F1,%Z)] [is positive in cons(U1,V1)]  >>False

Try again using status Mul
Checking  (1) nil@X => X
 (meta X)[is acc in nil,X] [is positive in nil] [is acc in X]  >>True
Checking  (2) cons(Y,U)@V => cons(Y,U@V)
 (fun app>cons)
 (meta Y)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in Y] 
 (fun app=app) subterm comparison of args w. Mul Mul
 (meta U)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in U] 
 (meta V)[is acc in cons(Y,U),V] [is positive in cons(Y,U)] [is acc in V]  >>True
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. Mul Mul >>False
Found constructors: nil, cons, iconsc, app
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. RL RL
 (fun foldl>yap)
 (fun foldl>xap)
 (meta F1)[is acc in %Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)] [is positive in yap(xap(F1,%Z),%U)] [is positive in xap(F1,%Z)] [is positive in cons(U1,V1)]  >>False

Try again using status Mul
Checking  (3) foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (meta P)[is acc in %X.%Y.yap(xap(I,%X),%Y),P,nil] [is positive in yap(xap(I,%X),%Y)] [is acc in P]  >>True
Checking  (4) foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (fun foldl=foldl) subterm comparison of args w. Mul Mul >>False
#No idea..
******** Signature ********
 app : (list,list) -> list
 cons : (nat,list) -> list
 foldl : (((list,nat) -> list),list,list) -> list
 iconsc : (list,nat) -> list
 nil : list
 reverse : list -> list
 reverse1 : list -> list
 xap : (((list,nat) -> list),list,nat) -> list
 yap : ((nat -> list),nat) -> list
******** Computation Rules ********
 (1)  nil@X => X
 (2)  cons(Y,U)@V => cons(Y,U@V)
 (3)  foldl(%X.%Y.yap(xap(I,%X),%Y),P,nil) => P
 (4)  foldl(%Z.%U.yap(xap(F1,%Z),%U),Y1,cons(U1,V1)) => foldl(%V.%W.yap(xap(F1,%V),%W),yap(xap(F1,Y1),U1),V1)
 (5)  iconsc(W1,P1) => cons(P1,W1)
 (6)  reverse(X2) => foldl(%F.%G.yap(xap(iconsc,%F),%G),nil,X2)
 (7)  reverse1(Y2) => foldl(%I.%H.(cons(%H,nil)@%I),nil,Y2)
 (8)  xap(G2,V2) => G2[V2]
 (9)  yap(I2,P2) => I2[P2]

MAYBE