HRS union beta 16688 pair #381734639

details

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

run statistics

property	value
solver	sol 37957
configuration	default
runtime (wallclock)	0.972299098969 seconds
cpu usage	1.109656919
max memory	3.8756352E7

stage attributes

key	value
output-size	35150
starexec-result	YES

output

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

popout

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

job log

popout

actions all output return to HRS union beta 16688