/export/starexec/sandbox/solver/bin/starexec_run_ttt2-1.17+nonreach /export/starexec/sandbox/benchmark/theBenchmark.xml /export/starexec/sandbox/output/output_files


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


YES

Problem:
 digits() -> d(0())
 d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
 if(true(),x) -> cons(x,d(s(x)))
 if(false(),x) -> nil()
 le(0(),y) -> true()
 le(s(x),0()) -> false()
 le(s(x),s(y)) -> le(x,y)

Proof:
 DP Processor:
  DPs:
   digits#() -> d#(0())
   d#(x) -> le#(x,s(s(s(s(s(s(s(s(s(0()))))))))))
   d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
   if#(true(),x) -> d#(s(x))
   le#(s(x),s(y)) -> le#(x,y)
  TRS:
   digits() -> d(0())
   d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
   if(true(),x) -> cons(x,d(s(x)))
   if(false(),x) -> nil()
   le(0(),y) -> true()
   le(s(x),0()) -> false()
   le(s(x),s(y)) -> le(x,y)
  TDG Processor:
   DPs:
    digits#() -> d#(0())
    d#(x) -> le#(x,s(s(s(s(s(s(s(s(s(0()))))))))))
    d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
    if#(true(),x) -> d#(s(x))
    le#(s(x),s(y)) -> le#(x,y)
   TRS:
    digits() -> d(0())
    d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
    if(true(),x) -> cons(x,d(s(x)))
    if(false(),x) -> nil()
    le(0(),y) -> true()
    le(s(x),0()) -> false()
    le(s(x),s(y)) -> le(x,y)
   graph:
    if#(true(),x) -> d#(s(x)) ->
    d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
    if#(true(),x) -> d#(s(x)) ->
    d#(x) -> le#(x,s(s(s(s(s(s(s(s(s(0()))))))))))
    le#(s(x),s(y)) -> le#(x,y) ->
    le#(s(x),s(y)) -> le#(x,y)
    d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x) ->
    if#(true(),x) -> d#(s(x))
    d#(x) -> le#(x,s(s(s(s(s(s(s(s(s(0())))))))))) ->
    le#(s(x),s(y)) -> le#(x,y)
    digits#() -> d#(0()) ->
    d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
    digits#() -> d#(0()) -> d#(x) -> le#(x,s(s(s(s(s(s(s(s(s(0()))))))))))
   SCC Processor:
    #sccs: 2
    #rules: 3
    #arcs: 7/25
    DPs:
     if#(true(),x) -> d#(s(x))
     d#(x) -> if#(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
    TRS:
     digits() -> d(0())
     d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
     if(true(),x) -> cons(x,d(s(x)))
     if(false(),x) -> nil()
     le(0(),y) -> true()
     le(s(x),0()) -> false()
     le(s(x),s(y)) -> le(x,y)
    Bounds Processor:
     bound: 21
     enrichment: top-dp
     automaton:
      final states: {15,14}
      transitions:
       d{#,11}(215) -> 14*
       if{#,12}(226,215) -> 14*
       le12(107,222) -> 226*
       le12(143,223) -> 226*
       le12(17,220) -> 226*
       le12(179,224) -> 226*
       le12(13,217) -> 226*
       le12(13,219) -> 226*
       le12(215,225) -> 226*
       le12(52,221) -> 226*
       le12(13,216) -> 226*
       le12(13,218) -> 226*
       s12(222) -> 223*
       s12(217) -> 218*
       s12(224) -> 225*
       s12(219) -> 220*
       s12(221) -> 222*
       s12(216) -> 217*
       s12(191) -> 227*
       s12(223) -> 224*
       s12(218) -> 219*
       s12(220) -> 221*
       012() -> 216*
       true11() -> 202*
       d{#,12}(227) -> 15*
       if{#,13}(238,227) -> 15*
       le13(79,233) -> 238*
       le13(40,232) -> 238*
       le13(13,229) -> 238*
       le13(13,231) -> 238*
       le13(119,234) -> 238*
       le13(155,235) -> 238*
       le13(191,236) -> 238*
       le13(227,237) -> 238*
       le13(13,228) -> 238*
       le13(13,230) -> 238*
       s13(232) -> 233*
       s13(234) -> 235*
       s13(229) -> 230*
       s13(236) -> 237*
       s13(231) -> 232*
       s13(233) -> 234*
       s13(228) -> 229*
       s13(235) -> 236*
       s13(230) -> 231*
       s13(215) -> 239*
       013() -> 228*
       false10() -> 190*
       false11() -> 202*
       true12() -> 226*
       d{#,13}(239) -> 14*
       if{#,0}(13,13) -> 14*
       if{#,14}(250,239) -> 14*
       true0() -> 13*
       le14(13,240) -> 250*
       le14(107,245) -> 250*
       le14(13,242) -> 250*
       le14(143,246) -> 250*
       le14(17,243) -> 250*
       le14(239,249) -> 250*
       le14(179,247) -> 250*
       le14(215,248) -> 250*
       le14(13,241) -> 250*
       le14(52,244) -> 250*
       d{#,0}(13) -> 15*
       s14(247) -> 248*
       s14(242) -> 243*
       s14(227) -> 251*
       s14(244) -> 245*
       s14(246) -> 247*
       s14(241) -> 242*
       s14(248) -> 249*
       s14(243) -> 244*
       s14(245) -> 246*
       s14(240) -> 241*
       s0(13) -> 13*
       014() -> 240*
       le0(13,13) -> 13*
       true13() -> 238*
       00() -> 13*
       d{#,14}(251) -> 15*
       digits0() -> 13*
       if{#,15}(262,251) -> 15*
       d0(13) -> 13*
       le15(13,252) -> 262*
       le15(13,254) -> 262*
       le15(119,257) -> 262*
       le15(155,258) -> 262*
       le15(251,261) -> 262*
       le15(191,259) -> 262*
       le15(227,260) -> 262*
       le15(13,253) -> 262*
       le15(79,256) -> 262*
       le15(40,255) -> 262*
       if0(13,13) -> 13*
       s15(257) -> 258*
       s15(252) -> 253*
       s15(259) -> 260*
       s15(254) -> 255*
       s15(239) -> 275*
       s15(256) -> 257*
       s15(258) -> 259*
       s15(253) -> 254*
       s15(260) -> 261*
       s15(255) -> 256*
       cons0(13,13) -> 13*
       015() -> 252*
       false0() -> 13*
       false12() -> 226*
       nil0() -> 13*
       false13() -> 238*
       if{#,1}(28,13) -> 15*
       true14() -> 250*
       le1(13,19) -> 28*
       le1(13,21) -> 28*
       le1(13,23) -> 28*
       le1(13,25) -> 28*
       le1(13,27) -> 28*
       le1(13,18) -> 28*
       le1(13,20) -> 28*
       le1(13,22) -> 28*
       le1(13,24) -> 28*
       le1(13,26) -> 28*
       d{#,15}(275) -> 14*
       s1(25) -> 26*
       s1(20) -> 21*
       s1(22) -> 23*
       s1(24) -> 25*
       s1(19) -> 20*
       s1(26) -> 27*
       s1(21) -> 22*
       s1(23) -> 24*
       s1(18) -> 19*
       s1(13) -> 17*
       if{#,16}(286,275) -> 14*
       01() -> 18*
       le16(52,279) -> 286*
       le16(13,276) -> 286*
       le16(107,280) -> 286*
       le16(143,281) -> 286*
       le16(17,278) -> 286*
       le16(239,284) -> 286*
       le16(179,282) -> 286*
       le16(275,285) -> 286*
       le16(13,277) -> 286*
       le16(215,283) -> 286*
       d{#,1}(17) -> 14*
       s16(282) -> 283*
       s16(277) -> 278*
       s16(284) -> 285*
       s16(279) -> 280*
       s16(281) -> 282*
       s16(276) -> 277*
       s16(251) -> 287*
       s16(283) -> 284*
       s16(278) -> 279*
       s16(280) -> 281*
       if{#,2}(39,17) -> 14*
       016() -> 276*
       le2(17,38) -> 39*
       le2(13,29) -> 39*
       le2(13,31) -> 39*
       le2(13,33) -> 39*
       le2(13,35) -> 39*
       le2(13,37) -> 39*
       le2(13,30) -> 39*
       le2(13,32) -> 39*
       le2(13,34) -> 39*
       le2(13,36) -> 39*
       true15() -> 262*
       s2(35) -> 36*
       s2(30) -> 31*
       s2(37) -> 38*
       s2(32) -> 33*
       s2(34) -> 35*
       s2(29) -> 30*
       s2(36) -> 37*
       s2(31) -> 32*
       s2(33) -> 34*
       s2(13) -> 40*
       d{#,16}(287) -> 15*
       02() -> 29*
       if{#,17}(298,287) -> 15*
       true1() -> 28*
       le17(155,293) -> 298*
       le17(251,296) -> 298*
       le17(191,294) -> 298*
       le17(287,297) -> 298*
       le17(227,295) -> 298*
       le17(13,288) -> 298*
       le17(79,291) -> 298*
       le17(40,290) -> 298*
       le17(13,289) -> 298*
       le17(119,292) -> 298*
       d{#,2}(40) -> 15*
       s17(292) -> 293*
       s17(294) -> 295*
       s17(289) -> 290*
       s17(296) -> 297*
       s17(291) -> 292*
       s17(293) -> 294*
       s17(288) -> 289*
       s17(295) -> 296*
       s17(290) -> 291*
       s17(275) -> 299*
       if{#,3}(51,40) -> 15*
       017() -> 288*
       le3(13,41) -> 51*
       le3(13,43) -> 51*
       le3(13,45) -> 51*
       le3(13,47) -> 51*
       le3(13,49) -> 51*
       le3(13,42) -> 51*
       le3(13,44) -> 51*
       le3(13,46) -> 51*
       le3(13,48) -> 51*
       le3(40,50) -> 51*
       false14() -> 250*
       s3(45) -> 46*
       s3(47) -> 48*
       s3(42) -> 43*
       s3(17) -> 52*
       s3(49) -> 50*
       s3(44) -> 45*
       s3(46) -> 47*
       s3(41) -> 42*
       s3(48) -> 49*
       s3(43) -> 44*
       false15() -> 262*
       03() -> 41*
       true16() -> 286*
       true2() -> 39*
       d{#,17}(299) -> 14*
       d{#,3}(52) -> 14*
       if{#,18}(310,299) -> 14*
       if{#,4}(74,52) -> 14*
       le18(107,303) -> 310*
       le18(299,309) -> 310*
       le18(143,304) -> 310*
       le18(17,301) -> 310*
       le18(239,307) -> 310*
       le18(179,305) -> 310*
       le18(275,308) -> 310*
       le18(13,300) -> 310*
       le18(215,306) -> 310*
       le18(52,302) -> 310*
       le4(17,72) -> 74*
       le4(13,65) -> 74*
       le4(13,67) -> 74*
       le4(13,69) -> 74*
       le4(13,71) -> 74*
       le4(52,73) -> 74*
       le4(13,64) -> 74*
       le4(13,66) -> 74*
       le4(13,68) -> 74*
       le4(13,70) -> 74*
       s18(307) -> 308*
       s18(302) -> 303*
       s18(287) -> 311*
       s18(304) -> 305*
       s18(306) -> 307*
       s18(301) -> 302*
       s18(308) -> 309*
       s18(303) -> 304*
       s18(305) -> 306*
       s18(300) -> 301*
       s4(70) -> 71*
       s4(65) -> 66*
       s4(40) -> 79*
       s4(72) -> 73*
       s4(67) -> 68*
       s4(69) -> 70*
       s4(64) -> 65*
       s4(71) -> 72*
       s4(66) -> 67*
       s4(68) -> 69*
       018() -> 300*
       04() -> 64*
       false16() -> 286*
       true3() -> 51*
       true17() -> 298*
       d{#,4}(79) -> 15*
       d{#,18}(311) -> 15*
       if{#,5}(92,79) -> 15*
       if{#,19}(323,311) -> 15*
       le5(13,86) -> 92*
       le5(13,88) -> 92*
       le5(79,91) -> 92*
       le5(40,90) -> 92*
       le5(13,83) -> 92*
       le5(13,85) -> 92*
       le5(13,87) -> 92*
       le5(13,89) -> 92*
       le5(13,82) -> 92*
       le5(13,84) -> 92*
       le19(13,313) -> 323*
       le19(119,316) -> 323*
       le19(311,322) -> 323*
       le19(155,317) -> 323*
       le19(251,320) -> 323*
       le19(191,318) -> 323*
       le19(287,321) -> 323*
       le19(227,319) -> 323*
       le19(79,315) -> 323*
       le19(40,314) -> 323*
       s5(90) -> 91*
       s5(85) -> 86*
       s5(87) -> 88*
       s5(82) -> 83*
       s5(52) -> 107*
       s5(89) -> 90*
       s5(84) -> 85*
       s5(86) -> 87*
       s5(88) -> 89*
       s5(83) -> 84*
       s19(317) -> 318*
       s19(319) -> 320*
       s19(314) -> 315*
       s19(299) -> 335*
       s19(321) -> 322*
       s19(316) -> 317*
       s19(318) -> 319*
       s19(313) -> 314*
       s19(320) -> 321*
       s19(315) -> 316*
       05() -> 82*
       019() -> 313*
       true4() -> 74*
       false17() -> 298*
       d{#,5}(107) -> 14*
       false18() -> 310*
       if{#,6}(118,107) -> 14*
       true18() -> 310*
       le6(13,108) -> 118*
       le6(13,110) -> 118*
       le6(13,112) -> 118*
       le6(107,117) -> 118*
       le6(17,115) -> 118*
       le6(13,114) -> 118*
       le6(13,109) -> 118*
       le6(13,111) -> 118*
       le6(52,116) -> 118*
       le6(13,113) -> 118*
       d{#,19}(335) -> 14*
       s6(115) -> 116*
       s6(110) -> 111*
       s6(112) -> 113*
       s6(114) -> 115*
       s6(109) -> 110*
       s6(79) -> 119*
       s6(116) -> 117*
       s6(111) -> 112*
       s6(113) -> 114*
       s6(108) -> 109*
       if{#,20}(346,335) -> 14*
       06() -> 108*
       le20(107,338) -> 346*
       le20(299,344) -> 346*
       le20(143,339) -> 346*
       le20(17,336) -> 346*
       le20(239,342) -> 346*
       le20(335,345) -> 346*
       le20(179,340) -> 346*
       le20(275,343) -> 346*
       le20(215,341) -> 346*
       le20(52,337) -> 346*
       true5() -> 92*
       s20(342) -> 343*
       s20(337) -> 338*
       s20(344) -> 345*
       s20(339) -> 340*
       s20(341) -> 342*
       s20(336) -> 337*
       s20(311) -> 347*
       s20(343) -> 344*
       s20(338) -> 339*
       s20(340) -> 341*
       d{#,6}(119) -> 15*
       020() -> 336*
       if{#,7}(130,119) -> 15*
       false19() -> 323*
       le7(40,127) -> 130*
       le7(13,120) -> 130*
       le7(13,122) -> 130*
       le7(13,124) -> 130*
       le7(13,126) -> 130*
       le7(119,129) -> 130*
       le7(13,121) -> 130*
       le7(13,123) -> 130*
       le7(13,125) -> 130*
       le7(79,128) -> 130*
       true19() -> 323*
       s7(125) -> 126*
       s7(120) -> 121*
       s7(127) -> 128*
       s7(122) -> 123*
       s7(107) -> 143*
       s7(124) -> 125*
       s7(126) -> 127*
       s7(121) -> 122*
       s7(128) -> 129*
       s7(123) -> 124*
       d{#,20}(347) -> 15*
       07() -> 120*
       if{#,21}(358,347) -> 15*
       true6() -> 118*
       le21(119,350) -> 358*
       le21(311,356) -> 358*
       le21(155,351) -> 358*
       le21(251,354) -> 358*
       le21(347,357) -> 358*
       le21(191,352) -> 358*
       le21(287,355) -> 358*
       le21(227,353) -> 358*
       le21(79,349) -> 358*
       le21(40,348) -> 358*
       d{#,7}(143) -> 14*
       s21(352) -> 353*
       s21(354) -> 355*
       s21(349) -> 350*
       s21(356) -> 357*
       s21(351) -> 352*
       s21(353) -> 354*
       s21(348) -> 349*
       s21(355) -> 356*
       s21(350) -> 351*
       if{#,8}(154,143) -> 14*
       021() -> 348*
       le8(13,147) -> 154*
       le8(13,149) -> 154*
       le8(52,151) -> 154*
       le8(13,144) -> 154*
       le8(13,146) -> 154*
       le8(13,148) -> 154*
       le8(107,152) -> 154*
       le8(143,153) -> 154*
       le8(17,150) -> 154*
       le8(13,145) -> 154*
       false20() -> 346*
       s8(152) -> 153*
       s8(147) -> 148*
       s8(149) -> 150*
       s8(144) -> 145*
       s8(119) -> 155*
       s8(151) -> 152*
       s8(146) -> 147*
       s8(148) -> 149*
       s8(150) -> 151*
       s8(145) -> 146*
       false21() -> 358*
       08() -> 144*
       false2() -> 39*
       false1() -> 28*
       true7() -> 130*
       d{#,8}(155) -> 15*
       if{#,9}(166,155) -> 15*
       le9(13,157) -> 166*
       le9(13,159) -> 166*
       le9(13,161) -> 166*
       le9(119,164) -> 166*
       le9(155,165) -> 166*
       le9(13,156) -> 166*
       le9(13,158) -> 166*
       le9(13,160) -> 166*
       le9(79,163) -> 166*
       le9(40,162) -> 166*
       s9(162) -> 163*
       s9(157) -> 158*
       s9(164) -> 165*
       s9(159) -> 160*
       s9(161) -> 162*
       s9(156) -> 157*
       s9(163) -> 164*
       s9(158) -> 159*
       s9(143) -> 179*
       s9(160) -> 161*
       09() -> 156*
       false3() -> 51*
       false4() -> 74*
       false5() -> 92*
       true8() -> 154*
       d{#,9}(179) -> 14*
       if{#,10}(190,179) -> 14*
       le10(52,186) -> 190*
       le10(13,181) -> 190*
       le10(13,183) -> 190*
       le10(107,187) -> 190*
       le10(143,188) -> 190*
       le10(17,185) -> 190*
       le10(179,189) -> 190*
       le10(13,180) -> 190*
       le10(13,182) -> 190*
       le10(13,184) -> 190*
       s10(155) -> 191*
       s10(187) -> 188*
       s10(182) -> 183*
       s10(184) -> 185*
       s10(186) -> 187*
       s10(181) -> 182*
       s10(188) -> 189*
       s10(183) -> 184*
       s10(185) -> 186*
       s10(180) -> 181*
       010() -> 180*
       false6() -> 118*
       true9() -> 166*
       d{#,10}(191) -> 15*
       if{#,11}(202,191) -> 15*
       le11(13,193) -> 202*
       le11(13,195) -> 202*
       le11(79,198) -> 202*
       le11(40,197) -> 202*
       le11(13,192) -> 202*
       le11(13,194) -> 202*
       le11(13,196) -> 202*
       le11(119,199) -> 202*
       le11(155,200) -> 202*
       le11(191,201) -> 202*
       s11(197) -> 198*
       s11(192) -> 193*
       s11(199) -> 200*
       s11(194) -> 195*
       s11(179) -> 215*
       s11(196) -> 197*
       s11(198) -> 199*
       s11(193) -> 194*
       s11(200) -> 201*
       s11(195) -> 196*
       011() -> 192*
       false7() -> 130*
       false8() -> 154*
       false9() -> 166*
       true10() -> 190*
     problem:
      DPs:
       
      TRS:
       digits() -> d(0())
       d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
       if(true(),x) -> cons(x,d(s(x)))
       if(false(),x) -> nil()
       le(0(),y) -> true()
       le(s(x),0()) -> false()
       le(s(x),s(y)) -> le(x,y)
     Qed
    
    DPs:
     le#(s(x),s(y)) -> le#(x,y)
    TRS:
     digits() -> d(0())
     d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
     if(true(),x) -> cons(x,d(s(x)))
     if(false(),x) -> nil()
     le(0(),y) -> true()
     le(s(x),0()) -> false()
     le(s(x),s(y)) -> le(x,y)
    Subterm Criterion Processor:
     simple projection:
      pi(le#) = 0
     problem:
      DPs:
       
      TRS:
       digits() -> d(0())
       d(x) -> if(le(x,s(s(s(s(s(s(s(s(s(0())))))))))),x)
       if(true(),x) -> cons(x,d(s(x)))
       if(false(),x) -> nil()
       le(0(),y) -> true()
       le(s(x),0()) -> false()
       le(s(x),s(y)) -> le(x,y)
     Qed