/export/starexec/sandbox2/solver/bin/starexec_run_default /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: if(true(),X,Y) -> X
    2: if(false(),X,Y) -> Y
    3: lteq(s(M),o()) -> false()
    4: lteq(o(),M) -> true()
    5: lteq(s(M),s(K)) -> lteq(M,K)
    6: from(M,nil()) -> nil()
    7: from(M,cons(H,Z)) -> if(lteq(M,H),cons(H,Z),from(M,Z))
    8: _(X1,X2) -> X1
    9: _(X1,X2) -> X2
Number of strict rules: 9
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #from(M,cons(H,Z)) -> #if(lteq(M,H),cons(H,Z),from(M,Z))
   #2: #from(M,cons(H,Z)) -> #lteq(M,H)
   #3: #from(M,cons(H,Z)) -> #from(M,Z)
   #4: #lteq(s(M),s(K)) -> #lteq(M,K)
Number of SCCs: 2, DPs: 2
  SCC { #3 }
POLO(Sum)... succeeded.
      s 	w: 0
      #lteq	w: 0
      false	w: 0
      _ 	w: 0
      true	w: 0
      o 	w: 0
      lteq	w: 0
      if	w: 0
      from	w: 0
      nil	w: 0
      #_ 	w: 0
      #from	w: x2
      cons	w: x2 + 1
      #if	w: 0
    USABLE RULES: { }
    Removed DPs: #3
Number of SCCs: 1, DPs: 1
  SCC { #4 }
POLO(Sum)... succeeded.
      s 	w: x1 + 1
      #lteq	w: x1
      false	w: 0
      _ 	w: 0
      true	w: 0
      o 	w: 0
      lteq	w: 0
      if	w: 0
      from	w: 0
      nil	w: 0
      #_ 	w: 0
      #from	w: 0
      cons	w: 1
      #if	w: 0
    USABLE RULES: { }
    Removed DPs: #4
Number of SCCs: 0, DPs: 0

...
Input TRS:
    1: if(true(),X,Y) -> X
    2: if(false(),X,Y) -> Y
    3: lteq(s(M),o()) -> false()
    4: lteq(o(),M) -> true()
    5: lteq(s(M),s(K)) -> lteq(M,K)
    6: from(M,nil()) -> nil()
    7: from(M,cons(H,Z)) -> if(lteq(M,H),cons(H,Z),from(M,Z))
    8: _(X1,X2) -> X1
    9: _(X1,X2) -> X2
Number of strict rules: 9
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #from(M,cons(H,Z)) -> #if(lteq(M,H),cons(H,Z),from(M,Z))
   #2: #from(M,cons(H,Z)) -> #lteq(M,H)
   #3: #from(M,cons(H,Z)) -> #from(M,Z)
   #4: #lteq(s(M),s(K)) -> #lteq(M,K)
Number of SCCs: 2, DPs: 2
  SCC { #3 }
POLO(Sum)... succeeded.
      s 	w: 0
      #lteq	w: 0
      false	w: 0
      _ 	w: 0
      true	w: 0
      o 	w: 0
      lteq	w: 0
      if	w: 0
      from	w: 0
      nil	w: 0
      #_ 	w: 0
      #from	w: x2
      cons	w: x2 + 1
      #if	w: 0
    USABLE RULES: { }
    Removed DPs: #3
Number of SCCs: 1, DPs: 1
  SCC { #4 }
POLO(Sum)... succeeded.
      s 	w: x1 + 1
      #lteq	w: x1
      false	w: 0
      _ 	w: 0
      true	w: 0
      o 	w: 0
      lteq	w: 0
      if	w: 0
      from	w: 0
      nil	w: 0
      #_ 	w: 0
      #from	w: 0
      cons	w: 1
      #if	w: 0
    USABLE RULES: { }
    Removed DPs: #4
Number of SCCs: 0, DPs: 0
>>YES

******** Signature ********
 chain : ((N -> N),list) -> list
 nil : list
 cons : (N,list) -> list
 from : (N,list) -> list
 incch : list -> list
 s : N -> N
******** Computation rules ********
 (8)  chain(F,nil) => nil
 (9)  chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (10)  incch(X) => chain(x.s(x),X)


******** General Schema criterion ********
Found constructors: o, s, true, false, nil, cons
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,X,Y) => Y
 (meta Y)[is acc in false,X,Y] [is positive in false] [is acc in Y]  >>True
Checking  (3) lteq(s(M),o) => false
 (fun lteq>false) >>True
Checking  (4) lteq(o,M) => true
 (fun lteq>true) >>True
Checking  (5) lteq(s(M),s(K)) => lteq(M,K)
 (fun lteq=lteq) subterm comparison of args w. LR LR
 (meta M)[is acc in s(M),s(K)] [is positive in s(M)] [is acc in M] 
 (meta K)[is acc in s(M),s(K)] [is positive in s(M)] [is positive in s(K)] [is acc in K]  >>True
Checking  (6) from(M,nil) => nil
 (fun from>nil) >>True
Checking  (7) from(M,cons(H,Z)) => if(lteq(M,H),cons(H,Z),from(M,Z))
 (fun from>if)
 (fun from>lteq)
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun from>cons)
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z] 
 (fun from=from) subterm comparison of args w. LR LR
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z]  >>True
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,X,Y) => Y
 (meta Y)[is acc in false,X,Y] [is positive in false] [is acc in Y]  >>True
Checking  (3) lteq(s(M),o) => false
 (fun lteq>false) >>True
Checking  (4) lteq(o,M) => true
 (fun lteq>true) >>True
Checking  (5) lteq(s(M),s(K)) => lteq(M,K)
 (fun lteq=lteq) subterm comparison of args w. RL RL
 (meta M)[is acc in s(M),s(K)] [is positive in s(M)] [is acc in M] 
 (meta K)[is acc in s(M),s(K)] [is positive in s(M)] [is positive in s(K)] [is acc in K]  >>True
Checking  (6) from(M,nil) => nil
 (fun from>nil) >>True
Checking  (7) from(M,cons(H,Z)) => if(lteq(M,H),cons(H,Z),from(M,Z))
 (fun from>if)
 (fun from>lteq)
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun from>cons)
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z] 
 (fun from=from) subterm comparison of args w. RL RL
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z]  >>True
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. RL RL >>False

Try again using status Mul
Checking  (1) if(true,X,Y) => X
 (meta X)[is acc in true,X,Y] [is positive in true] [is acc in X]  >>True
Checking  (2) if(false,X,Y) => Y
 (meta Y)[is acc in false,X,Y] [is positive in false] [is acc in Y]  >>True
Checking  (3) lteq(s(M),o) => false
 (fun lteq>false) >>True
Checking  (4) lteq(o,M) => true
 (fun lteq>true) >>True
Checking  (5) lteq(s(M),s(K)) => lteq(M,K)
 (fun lteq=lteq) subterm comparison of args w. Mul Mul
 (meta M)[is acc in s(M),s(K)] [is positive in s(M)] [is acc in M] 
 (meta K)[is acc in s(M),s(K)] [is positive in s(M)] [is positive in s(K)] [is acc in K]  >>True
Checking  (6) from(M,nil) => nil
 (fun from>nil) >>True
Checking  (7) from(M,cons(H,Z)) => if(lteq(M,H),cons(H,Z),from(M,Z))
 (fun from>if)
 (fun from>lteq)
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun from>cons)
 (meta H)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z] 
 (fun from=from) subterm comparison of args w. Mul Mul
 (meta M)[is acc in M,cons(H,Z)] [is acc in M] 
 (meta Z)[is acc in M,cons(H,Z)] [is positive in cons(H,Z)] [is acc in Z]  >>True
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. Mul Mul >>False
Found constructors: nil, cons, from, s
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>OK
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. RL RL >>False

Try again using status Mul
Checking  (8) chain(F,nil) => nil
 (fun chain>nil) >>True
Checking  (9) chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (fun chain>cons)
 (meta F)[is acc in F,cons(H,Z)] [is acc in F] 
 (meta H)[is acc in F,cons(H,Z)] [is positive in cons(H,Z)] [is acc in H] 
 (fun chain=chain) subterm comparison of args w. Mul Mul >>False
#No idea..
******** Signature ********
 o : N
 s : N -> N
 true : B
 false : B
 nil : list
 cons : (N,list) -> list
 if : (B,list,list) -> list
 lteq : (N,N) -> B
 from : (N,list) -> list
 chain : ((N -> N),list) -> list
 incch : list -> list
******** Computation Rules ********
 (1)  if(true,X,Y) => X
 (2)  if(false,X,Y) => Y
 (3)  lteq(s(M),o) => false
 (4)  lteq(o,M) => true
 (5)  lteq(s(M),s(K)) => lteq(M,K)
 (6)  from(M,nil) => nil
 (7)  from(M,cons(H,Z)) => if(lteq(M,H),cons(H,Z),from(M,Z))
 (8)  chain(F,nil) => nil
 (9)  chain(F,cons(H,Z)) => cons(F[H],chain(F,from(F[H],Z)))
 (10)  incch(X) => chain(x.s(x),X)

MAYBE