HRS union beta 16688 pair #381734513

details

property	value
status	complete
benchmark	h22.xml
ran by	Akihisa Yamada
cpu timeout	1200 seconds
wallclock timeout	300 seconds
memory limit	137438953472 bytes
execution host	n038.star.cs.uiowa.edu
space	Hamana_Kikuchi_18

run statistics

property	value
solver	sol 37957
configuration	default
runtime (wallclock)	0.651000022888 seconds
cpu usage	0.725429452
max memory	2.8168192E7

stage attributes

key	value
output-size	25031
starexec-result	YES

output

/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: axxnatsFrom(X) -> cons(mark(X),natsFrom(s(X)))
    2: axxfst(pair(Y,U)) -> mark(Y)
    3: axxsnd(pair(V,W)) -> mark(W)
    4: axxsplitAt(0(),P) -> pair(nil(),mark(P))
    5: axxsplitAt(s(X1),cons(Y1,U1)) -> axxu(axxsplitAt(mark(X1),mark(U1)),X1,Y1,U1)
    6: axxu(pair(V1,W1),P1,X2,Y2) -> pair(cons(mark(X2),V1),mark(W1))
    7: axxhead(cons(U2,V2)) -> mark(U2)
    8: axxtail(cons(W2,P2)) -> mark(P2)
    9: axxsel(X3,Y3) -> axxhead(axxafterNth(mark(X3),mark(Y3)))
    10: axxtake(U3,V3) -> axxfst(axxsplitAt(mark(U3),mark(V3)))
    11: axxafterNth(W3,P3) -> axxsnd(axxsplitAt(mark(W3),mark(P3)))
    12: mark(natsFrom(X4)) -> axxnatsFrom(mark(X4))
    13: mark(fst(Y4)) -> axxfst(mark(Y4))
    14: mark(snd(U4)) -> axxsnd(mark(U4))
    15: mark(splitAt(V4,W4)) -> axxsplitAt(mark(V4),mark(W4))
    16: mark(u(P4,X5,Y5,U5)) -> axxu(mark(P4),X5,Y5,U5)
    17: mark(head(V5)) -> axxhead(mark(V5))
    18: mark(tail(W5)) -> axxtail(mark(W5))
    19: mark(sel(P5,X6)) -> axxsel(mark(P5),mark(X6))
    20: mark(afterNth(Y6,U6)) -> axxafterNth(mark(Y6),mark(U6))
    21: mark(take(V6,W6)) -> axxtake(mark(V6),mark(W6))
    22: mark(cons(P6,X7)) -> cons(mark(P6),X7)
    23: mark(s(Y7)) -> s(mark(Y7))
    24: mark(pair(U7,V7)) -> pair(mark(U7),mark(V7))
    25: mark(0()) -> 0()
    26: mark(nil()) -> nil()
    27: axxnatsFrom(W7) -> natsFrom(W7)
    28: axxfst(P7) -> fst(P7)
    29: axxsnd(X8) -> snd(X8)
    30: axxsplitAt(Y8,U8) -> splitAt(Y8,U8)
    31: axxu(V8,W8,P8,X9) -> u(V8,W8,P8,X9)
    32: axxhead(Y9) -> head(Y9)
    33: axxtail(U9) -> tail(U9)
    34: axxsel(V9,W9) -> sel(V9,W9)
    35: axxafterNth(P9,X10) -> afterNth(P9,X10)
    36: axxtake(Y10,U10) -> take(Y10,U10)
    37: _(X1,X2) -> X1
    38: _(X1,X2) -> X2
Number of strict rules: 38
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #axxfst(pair(Y,U)) -> #mark(Y)
   #2: #axxu(pair(V1,W1),P1,X2,Y2) -> #mark(X2)
   #3: #axxu(pair(V1,W1),P1,X2,Y2) -> #mark(W1)
   #4: #mark(fst(Y4)) -> #axxfst(mark(Y4))
   #5: #mark(fst(Y4)) -> #mark(Y4)
   #6: #axxsel(X3,Y3) -> #axxhead(axxafterNth(mark(X3),mark(Y3)))
   #7: #axxsel(X3,Y3) -> #axxafterNth(mark(X3),mark(Y3))
   #8: #axxsel(X3,Y3) -> #mark(X3)
   #9: #axxsel(X3,Y3) -> #mark(Y3)
   #10: #axxafterNth(W3,P3) -> #axxsnd(axxsplitAt(mark(W3),mark(P3)))
   #11: #axxafterNth(W3,P3) -> #axxsplitAt(mark(W3),mark(P3))
   #12: #axxafterNth(W3,P3) -> #mark(W3)
   #13: #axxafterNth(W3,P3) -> #mark(P3)
   #14: #mark(pair(U7,V7)) -> #mark(U7)
   #15: #mark(pair(U7,V7)) -> #mark(V7)
   #16: #mark(s(Y7)) -> #mark(Y7)
   #17: #mark(natsFrom(X4)) -> #axxnatsFrom(mark(X4))
   #18: #mark(natsFrom(X4)) -> #mark(X4)
   #19: #mark(snd(U4)) -> #axxsnd(mark(U4))
   #20: #mark(snd(U4)) -> #mark(U4)
   #21: #mark(afterNth(Y6,U6)) -> #axxafterNth(mark(Y6),mark(U6))
   #22: #mark(afterNth(Y6,U6)) -> #mark(Y6)
   #23: #mark(afterNth(Y6,U6)) -> #mark(U6)
   #24: #axxhead(cons(U2,V2)) -> #mark(U2)
   #25: #axxtake(U3,V3) -> #axxfst(axxsplitAt(mark(U3),mark(V3)))
   #26: #axxtake(U3,V3) -> #axxsplitAt(mark(U3),mark(V3))
   #27: #axxtake(U3,V3) -> #mark(U3)
   #28: #axxtake(U3,V3) -> #mark(V3)
   #29: #axxsplitAt(s(X1),cons(Y1,U1)) -> #axxu(axxsplitAt(mark(X1),mark(U1)),X1,Y1,U1)
   #30: #axxsplitAt(s(X1),cons(Y1,U1)) -> #axxsplitAt(mark(X1),mark(U1))
   #31: #axxsplitAt(s(X1),cons(Y1,U1)) -> #mark(X1)
   #32: #axxsplitAt(s(X1),cons(Y1,U1)) -> #mark(U1)
   #33: #mark(cons(P6,X7)) -> #mark(P6)
   #34: #mark(head(V5)) -> #axxhead(mark(V5))
   #35: #mark(head(V5)) -> #mark(V5)
   #36: #mark(sel(P5,X6)) -> #axxsel(mark(P5),mark(X6))
   #37: #mark(sel(P5,X6)) -> #mark(P5)
   #38: #mark(sel(P5,X6)) -> #mark(X6)
   #39: #mark(take(V6,W6)) -> #axxtake(mark(V6),mark(W6))
   #40: #mark(take(V6,W6)) -> #mark(V6)
   #41: #mark(take(V6,W6)) -> #mark(W6)
   #42: #mark(u(P4,X5,Y5,U5)) -> #axxu(mark(P4),X5,Y5,U5)
   #43: #mark(u(P4,X5,Y5,U5)) -> #mark(P4)
   #44: #axxsnd(pair(V,W)) -> #mark(W)
   #45: #axxnatsFrom(X) -> #mark(X)

popout

output may be truncated. 'popout' for the full output.

job log

popout

actions all output return to HRS union beta 16688