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


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


YES

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: xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
    2: _(X1,X2) -> X1
    3: _(X1,X2) -> X2
Number of strict rules: 3
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
   #2: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(Y,V)
   #3: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(xbcolon(Y,U),V),X)
   #4: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(Y,U),V)
   #5: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(Y,U)
Number of SCCs: 1, DPs: 5
  SCC { #1..5 }
POLO(Sum)... POLO(max)... succeeded.
      xbcolon	w: max(x1 + 2456, x2)
      #xbcolon	w: max(x1 + 18314, x2 + 15858)
      c 	w: 609
      _ 	w: 0
      #_ 	w: 0
    USABLE RULES: { 1 }
    Removed DPs: #2 #4 #5
Number of SCCs: 1, DPs: 2
  SCC { #1 #3 }
POLO(Sum)... POLO(max)... QLPOS... succeeded.
      xbcolon	s: [1,2]	p: 1
      #xbcolon	s: [1]	p: 1
      c 	s: []	p: 0
      _ 	s: []	p: 0
      #_ 	s: [2]	p: 0
    USABLE RULES: { 1 }
    Removed DPs: #1 #3
Number of SCCs: 0, DPs: 0

...
Input TRS:
    1: xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
    2: _(X1,X2) -> X1
    3: _(X1,X2) -> X2
Number of strict rules: 3
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
   #2: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(Y,V)
   #3: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(xbcolon(Y,U),V),X)
   #4: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(xbcolon(Y,U),V)
   #5: #xbcolon(xbcolon(xbcolon(xbcolon(c(),Y),U),V),X) -> #xbcolon(Y,U)
Number of SCCs: 1, DPs: 5
  SCC { #1..5 }
POLO(Sum)... POLO(max)... succeeded.
      xbcolon	w: max(x1 + 2456, x2)
      #xbcolon	w: max(x1 + 18314, x2 + 15858)
      c 	w: 609
      _ 	w: 0
      #_ 	w: 0
    USABLE RULES: { 1 }
    Removed DPs: #2 #4 #5
Number of SCCs: 1, DPs: 2
  SCC { #1 #3 }
POLO(Sum)... POLO(max)... QLPOS... succeeded.
      xbcolon	s: [1,2]	p: 1
      #xbcolon	s: [1]	p: 1
      c 	s: []	p: 0
      _ 	s: []	p: 0
      #_ 	s: [2]	p: 0
    USABLE RULES: { 1 }
    Removed DPs: #1 #3
Number of SCCs: 0, DPs: 0
>>YES

******** Signature ********
 map : ((c -> c),d) -> d
 nil : d
 cons : (c,d) -> d
 filter : ((c -> b),d) -> d
 filter2 : (b,(c -> b),c,d) -> d
 true : b
 false : b
******** Computation rules ********
 (2)  map(I,nil) => nil
 (3)  map(J,cons(X1,Y1)) => cons(J[X1],map(J,Y1))
 (4)  filter(G1,nil) => nil
 (5)  filter(H1,cons(W1,P1)) => filter2(H1[W1],H1,W1,P1)
 (6)  filter2(true,F2,Y2,U2) => cons(Y2,filter(F2,U2))
 (7)  filter2(false,H2,W2,P2) => filter(H2,P2)


******** General Schema criterion ********
Found constructors: c, cons, false, nil, true
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>Regared as equal: filter2, filter
Checking  (1) xbcolon(xbcolon(xbcolon(xbcolon(c,Y),U),V),X) => xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
 (fun xbcolon=xbcolon) subterm comparison of args w. LR LR >>False

Try again using status RL
Checking  (1) xbcolon(xbcolon(xbcolon(xbcolon(c,Y),U),V),X) => xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
 (fun xbcolon=xbcolon) subterm comparison of args w. RL RL >>False

Try again using status Mul
Checking  (1) xbcolon(xbcolon(xbcolon(xbcolon(c,Y),U),V),X) => xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
 (fun xbcolon=xbcolon) subterm comparison of args w. Mul Mul >>False
Found constructors: nil, cons, true, false
Checking type order >>OK
Checking positivity of constructors >>OK
Checking function dependency >>Regared as equal: filter2, filter
Checking  (2) map(I,nil) => nil
 (fun map>nil) >>True
Checking  (3) map(J,cons(X1,Y1)) => cons(J[X1],map(J,Y1))
 (fun map>cons)
 (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 map=map) subterm comparison of args w. LR LR
 (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  (4) filter(G1,nil) => nil
 (fun filter>nil) >>True
Checking  (5) filter(H1,cons(W1,P1)) => filter2(H1[W1],H1,W1,P1)
 (fun filter=filter2) subterm comparison of args w. Arg [1,2] Arg [2,4,3,1]
 (meta H1)[is acc in H1,cons(W1,P1)] [is acc in H1] 
 (meta W1)[is acc in H1,cons(W1,P1)] [is positive in cons(W1,P1)] [is acc in W1] 
 (meta H1)[is acc in H1,cons(W1,P1)] [is acc in H1] 
 (meta W1)[is acc in H1,cons(W1,P1)] [is positive in cons(W1,P1)] [is acc in W1] 
 (meta P1)[is acc in H1,cons(W1,P1)] [is positive in cons(W1,P1)] [is acc in P1]  >>True
Checking  (6) filter2(true,F2,Y2,U2) => cons(Y2,filter(F2,U2))
 (fun filter2>cons)
 (meta Y2)[is acc in true,F2,Y2,U2] [is positive in true] [is acc in Y2] 
 (fun filter2=filter) subterm comparison of args w. Arg [2,4,3,1] Arg [1,2]
 (meta F2)[is acc in true,F2,Y2,U2] [is positive in true] [is acc in F2] 
 (meta U2)[is acc in true,F2,Y2,U2] [is positive in true] [is acc in U2]  >>True
Checking  (7) filter2(false,H2,W2,P2) => filter(H2,P2)
 (fun filter2=filter) subterm comparison of args w. Arg [2,4,3,1] Arg [1,2]
 (meta H2)[is acc in false,H2,W2,P2] [is positive in false] [is acc in H2] 
 (meta P2)[is acc in false,H2,W2,P2] [is positive in false] [is acc in P2]  >>True
#SN!
******** Signature ********
 xbcolon : (a,a) -> a
 c : a
 cons : (c,d) -> d
 false : b
 filter : ((c -> b),d) -> d
 filter2 : (b,(c -> b),c,d) -> d
 map : ((c -> c),d) -> d
 nil : d
 true : b
******** Computation Rules ********
 (1)  xbcolon(xbcolon(xbcolon(xbcolon(c,Y),U),V),X) => xbcolon(xbcolon(Y,V),xbcolon(xbcolon(xbcolon(Y,U),V),X))
 (2)  map(I,nil) => nil
 (3)  map(J,cons(X1,Y1)) => cons(J[X1],map(J,Y1))
 (4)  filter(G1,nil) => nil
 (5)  filter(H1,cons(W1,P1)) => filter2(H1[W1],H1,W1,P1)
 (6)  filter2(true,F2,Y2,U2) => cons(Y2,filter(F2,U2))
 (7)  filter2(false,H2,W2,P2) => filter(H2,P2)

YES