HRS union beta 16688 pair #381734540

details

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

run statistics

property	value
solver	sol 37957
configuration	default
runtime (wallclock)	1.56909203529 seconds
cpu usage	1.858039
max memory	5.0745344E7

stage attributes

key	value
output-size	60275
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: active(natsFrom(X)) -> mark(cons(X,natsFrom(s(X))))
    2: active(fst(pair(Y,U))) -> mark(Y)
    3: active(snd(pair(V,W))) -> mark(W)
    4: active(splitAt(0(),P)) -> mark(pair(nil(),P))
    5: active(splitAt(s(X1),cons(Y1,U1))) -> mark(u(splitAt(X1,U1),X1,Y1,U1))
    6: active(u(pair(V1,W1),P1,X2,Y2)) -> mark(pair(cons(X2,V1),W1))
    7: active(head(cons(U2,V2))) -> mark(U2)
    8: active(tail(cons(W2,P2))) -> mark(P2)
    9: active(sel(X3,Y3)) -> mark(head(afterNth(X3,Y3)))
    10: active(take(U3,V3)) -> mark(fst(splitAt(U3,V3)))
    11: active(afterNth(W3,P3)) -> mark(snd(splitAt(W3,P3)))
    12: mark(natsFrom(X4)) -> active(natsFrom(mark(X4)))
    13: mark(cons(Y4,U4)) -> active(cons(mark(Y4),U4))
    14: mark(s(V4)) -> active(s(mark(V4)))
    15: mark(fst(W4)) -> active(fst(mark(W4)))
    16: mark(pair(P4,X5)) -> active(pair(mark(P4),mark(X5)))
    17: mark(snd(Y5)) -> active(snd(mark(Y5)))
    18: mark(splitAt(U5,V5)) -> active(splitAt(mark(U5),mark(V5)))
    19: mark(0()) -> active(0())
    20: mark(nil()) -> active(nil())
    21: mark(u(W5,P5,X6,Y6)) -> active(u(mark(W5),P5,X6,Y6))
    22: mark(head(U6)) -> active(head(mark(U6)))
    23: mark(tail(V6)) -> active(tail(mark(V6)))
    24: mark(sel(W6,P6)) -> active(sel(mark(W6),mark(P6)))
    25: mark(afterNth(X7,Y7)) -> active(afterNth(mark(X7),mark(Y7)))
    26: mark(take(U7,V7)) -> active(take(mark(U7),mark(V7)))
    27: natsFrom(mark(W7)) -> natsFrom(W7)
    28: natsFrom(active(P7)) -> natsFrom(P7)
    29: cons(mark(X8),Y8) -> cons(X8,Y8)
    30: cons(U8,mark(V8)) -> cons(U8,V8)
    31: cons(active(W8),P8) -> cons(W8,P8)
    32: cons(X9,active(Y9)) -> cons(X9,Y9)
    33: s(mark(U9)) -> s(U9)
    34: s(active(V9)) -> s(V9)
    35: fst(mark(W9)) -> fst(W9)
    36: fst(active(P9)) -> fst(P9)
    37: pair(mark(X10),Y10) -> pair(X10,Y10)
    38: pair(U10,mark(V10)) -> pair(U10,V10)
    39: pair(active(W10),P10) -> pair(W10,P10)
    40: pair(X11,active(Y11)) -> pair(X11,Y11)
    41: snd(mark(U11)) -> snd(U11)
    42: snd(active(V11)) -> snd(V11)
    43: splitAt(mark(W11),P11) -> splitAt(W11,P11)
    44: splitAt(X12,mark(Y12)) -> splitAt(X12,Y12)
    45: splitAt(active(U12),V12) -> splitAt(U12,V12)
    46: splitAt(W12,active(P12)) -> splitAt(W12,P12)
    47: u(mark(X13),Y13,U13,V13) -> u(X13,Y13,U13,V13)
    48: u(W13,mark(P13),X14,Y14) -> u(W13,P13,X14,Y14)
    49: u(U14,V14,mark(W14),P14) -> u(U14,V14,W14,P14)
    50: u(X15,Y15,U15,mark(V15)) -> u(X15,Y15,U15,V15)
    51: u(active(W15),P15,X16,Y16) -> u(W15,P15,X16,Y16)
    52: u(U16,active(V16),W16,P16) -> u(U16,V16,W16,P16)
    53: u(X17,Y17,active(U17),V17) -> u(X17,Y17,U17,V17)
    54: u(W17,P17,X18,active(Y18)) -> u(W17,P17,X18,Y18)
    55: head(mark(U18)) -> head(U18)
    56: head(active(V18)) -> head(V18)
    57: tail(mark(W18)) -> tail(W18)
    58: tail(active(P18)) -> tail(P18)
    59: sel(mark(X19),Y19) -> sel(X19,Y19)
    60: sel(U19,mark(V19)) -> sel(U19,V19)
    61: sel(active(W19),P19) -> sel(W19,P19)
    62: sel(X20,active(Y20)) -> sel(X20,Y20)
    63: afterNth(mark(U20),V20) -> afterNth(U20,V20)
    64: afterNth(W20,mark(P20)) -> afterNth(W20,P20)
    65: afterNth(active(X21),Y21) -> afterNth(X21,Y21)
    66: afterNth(U21,active(V21)) -> afterNth(U21,V21)
    67: take(mark(W21),P21) -> take(W21,P21)
    68: take(X22,mark(Y22)) -> take(X22,Y22)
    69: take(active(U22),V22) -> take(U22,V22)
    70: take(W22,active(P22)) -> take(W22,P22)
    71: _(X1,X2) -> X1
    72: _(X1,X2) -> X2
Number of strict rules: 72
Direct POLO(bPol) ... failed.
Uncurrying ... failed.
Dependency Pairs:
   #1: #active(fst(pair(Y,U))) -> #mark(Y)
   #2: #splitAt(mark(W11),P11) -> #splitAt(W11,P11)
   #3: #cons(mark(X8),Y8) -> #cons(X8,Y8)
   #4: #fst(mark(W9)) -> #fst(W9)
   #5: #afterNth(U21,active(V21)) -> #afterNth(U21,V21)
   #6: #splitAt(W12,active(P12)) -> #splitAt(W12,P12)
   #7: #snd(active(V11)) -> #snd(V11)
   #8: #snd(mark(U11)) -> #snd(U11)
   #9: #pair(mark(X10),Y10) -> #pair(X10,Y10)
   #10: #u(mark(X13),Y13,U13,V13) -> #u(X13,Y13,U13,V13)
   #11: #u(X17,Y17,active(U17),V17) -> #u(X17,Y17,U17,V17)

popout

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

job log

popout

actions all output return to HRS union beta 16688