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


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


YES

Problem:
 even(0()) -> true()
 even(s(0())) -> false()
 even(s(s(x))) -> even(x)
 half(0()) -> 0()
 half(s(s(x))) -> s(half(x))
 plus(0(),y) -> y
 plus(s(x),y) -> s(plus(x,y))
 times(0(),y) -> 0()
 times(s(x),y) -> if_times(even(s(x)),s(x),y)
 if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
 if_times(false(),s(x),y) -> plus(y,times(x,y))

Proof:
 DP Processor:
  DPs:
   even#(s(s(x))) -> even#(x)
   half#(s(s(x))) -> half#(x)
   plus#(s(x),y) -> plus#(x,y)
   times#(s(x),y) -> even#(s(x))
   times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
   if_times#(true(),s(x),y) -> half#(s(x))
   if_times#(true(),s(x),y) -> times#(half(s(x)),y)
   if_times#(true(),s(x),y) -> plus#(times(half(s(x)),y),times(half(s(x)),y))
   if_times#(false(),s(x),y) -> times#(x,y)
   if_times#(false(),s(x),y) -> plus#(y,times(x,y))
  TRS:
   even(0()) -> true()
   even(s(0())) -> false()
   even(s(s(x))) -> even(x)
   half(0()) -> 0()
   half(s(s(x))) -> s(half(x))
   plus(0(),y) -> y
   plus(s(x),y) -> s(plus(x,y))
   times(0(),y) -> 0()
   times(s(x),y) -> if_times(even(s(x)),s(x),y)
   if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
   if_times(false(),s(x),y) -> plus(y,times(x,y))
  TDG Processor:
   DPs:
    even#(s(s(x))) -> even#(x)
    half#(s(s(x))) -> half#(x)
    plus#(s(x),y) -> plus#(x,y)
    times#(s(x),y) -> even#(s(x))
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
    if_times#(true(),s(x),y) -> half#(s(x))
    if_times#(true(),s(x),y) -> times#(half(s(x)),y)
    if_times#(true(),s(x),y) -> plus#(times(half(s(x)),y),times(half(s(x)),y))
    if_times#(false(),s(x),y) -> times#(x,y)
    if_times#(false(),s(x),y) -> plus#(y,times(x,y))
   TRS:
    even(0()) -> true()
    even(s(0())) -> false()
    even(s(s(x))) -> even(x)
    half(0()) -> 0()
    half(s(s(x))) -> s(half(x))
    plus(0(),y) -> y
    plus(s(x),y) -> s(plus(x,y))
    times(0(),y) -> 0()
    times(s(x),y) -> if_times(even(s(x)),s(x),y)
    if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
    if_times(false(),s(x),y) -> plus(y,times(x,y))
   graph:
    if_times#(false(),s(x),y) -> times#(x,y) ->
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
    if_times#(false(),s(x),y) -> times#(x,y) ->
    times#(s(x),y) -> even#(s(x))
    if_times#(false(),s(x),y) -> plus#(y,times(x,y)) ->
    plus#(s(x),y) -> plus#(x,y)
    if_times#(true(),s(x),y) -> times#(half(s(x)),y) ->
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
    if_times#(true(),s(x),y) -> times#(half(s(x)),y) ->
    times#(s(x),y) -> even#(s(x))
    if_times#(true(),s(x),y) -> plus#(times(half(s(x)),y),times(half(s(x)),y)) ->
    plus#(s(x),y) -> plus#(x,y)
    if_times#(true(),s(x),y) -> half#(s(x)) ->
    half#(s(s(x))) -> half#(x)
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y) ->
    if_times#(false(),s(x),y) -> plus#(y,times(x,y))
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y) ->
    if_times#(false(),s(x),y) -> times#(x,y)
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y) ->
    if_times#(true(),s(x),y) -> plus#(times(half(s(x)),y),times(half(s(x)),y))
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y) ->
    if_times#(true(),s(x),y) -> times#(half(s(x)),y)
    times#(s(x),y) -> if_times#(even(s(x)),s(x),y) ->
    if_times#(true(),s(x),y) -> half#(s(x))
    times#(s(x),y) -> even#(s(x)) -> even#(s(s(x))) -> even#(x)
    plus#(s(x),y) -> plus#(x,y) -> plus#(s(x),y) -> plus#(x,y)
    half#(s(s(x))) -> half#(x) -> half#(s(s(x))) -> half#(x)
    even#(s(s(x))) -> even#(x) -> even#(s(s(x))) -> even#(x)
   SCC Processor:
    #sccs: 4
    #rules: 6
    #arcs: 16/100
    DPs:
     if_times#(false(),s(x),y) -> times#(x,y)
     times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
     if_times#(true(),s(x),y) -> times#(half(s(x)),y)
    TRS:
     even(0()) -> true()
     even(s(0())) -> false()
     even(s(s(x))) -> even(x)
     half(0()) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(0(),y) -> 0()
     times(s(x),y) -> if_times(even(s(x)),s(x),y)
     if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
     if_times(false(),s(x),y) -> plus(y,times(x,y))
    Subterm Criterion Processor:
     simple projection:
      pi(s) = [0,0,0]
      pi(half) = 0
      pi(times#) = 0
      pi(if_times#) = 1
     problem:
      DPs:
       times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
       if_times#(true(),s(x),y) -> times#(half(s(x)),y)
      TRS:
       even(0()) -> true()
       even(s(0())) -> false()
       even(s(s(x))) -> even(x)
       half(0()) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(0(),y) -> 0()
       times(s(x),y) -> if_times(even(s(x)),s(x),y)
       if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
       if_times(false(),s(x),y) -> plus(y,times(x,y))
     Usable Rule Processor:
      DPs:
       times#(s(x),y) -> if_times#(even(s(x)),s(x),y)
       if_times#(true(),s(x),y) -> times#(half(s(x)),y)
      TRS:
       even(s(0())) -> false()
       even(s(s(x))) -> even(x)
       even(0()) -> true()
       half(s(s(x))) -> s(half(x))
       half(0()) -> 0()
      Arctic Interpretation Processor:
       dimension: 1
       usable rules:
        half(s(s(x))) -> s(half(x))
        half(0()) -> 0()
       interpretation:
        [if_times#](x0, x1, x2) = -1x1 + 0,
        
        [times#](x0, x1) = x0 + 0,
        
        [half](x0) = -1x0 + 0,
        
        [false] = 1,
        
        [s](x0) = 1x0 + 1,
        
        [true] = 4,
        
        [even](x0) = 2x0 + -16,
        
        [0] = 0
       orientation:
        times#(s(x),y) = 1x + 1 >= x + 0 = if_times#(even(s(x)),s(x),y)
        
        if_times#(true(),s(x),y) = x + 0 >= x + 0 = times#(half(s(x)),y)
        
        even(s(0())) = 3 >= 1 = false()
        
        even(s(s(x))) = 4x + 4 >= 2x + -16 = even(x)
        
        even(0()) = 2 >= 4 = true()
        
        half(s(s(x))) = 1x + 1 >= x + 1 = s(half(x))
        
        half(0()) = 0 >= 0 = 0()
       problem:
        DPs:
         if_times#(true(),s(x),y) -> times#(half(s(x)),y)
        TRS:
         even(s(0())) -> false()
         even(s(s(x))) -> even(x)
         even(0()) -> true()
         half(s(s(x))) -> s(half(x))
         half(0()) -> 0()
       Restore Modifier:
        DPs:
         if_times#(true(),s(x),y) -> times#(half(s(x)),y)
        TRS:
         even(0()) -> true()
         even(s(0())) -> false()
         even(s(s(x))) -> even(x)
         half(0()) -> 0()
         half(s(s(x))) -> s(half(x))
         plus(0(),y) -> y
         plus(s(x),y) -> s(plus(x,y))
         times(0(),y) -> 0()
         times(s(x),y) -> if_times(even(s(x)),s(x),y)
         if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
         if_times(false(),s(x),y) -> plus(y,times(x,y))
        SCC Processor:
         #sccs: 0
         #rules: 0
         #arcs: 4/1
         
    
    DPs:
     plus#(s(x),y) -> plus#(x,y)
    TRS:
     even(0()) -> true()
     even(s(0())) -> false()
     even(s(s(x))) -> even(x)
     half(0()) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(0(),y) -> 0()
     times(s(x),y) -> if_times(even(s(x)),s(x),y)
     if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
     if_times(false(),s(x),y) -> plus(y,times(x,y))
    Subterm Criterion Processor:
     simple projection:
      pi(plus#) = 0
     problem:
      DPs:
       
      TRS:
       even(0()) -> true()
       even(s(0())) -> false()
       even(s(s(x))) -> even(x)
       half(0()) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(0(),y) -> 0()
       times(s(x),y) -> if_times(even(s(x)),s(x),y)
       if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
       if_times(false(),s(x),y) -> plus(y,times(x,y))
     Qed
    
    DPs:
     half#(s(s(x))) -> half#(x)
    TRS:
     even(0()) -> true()
     even(s(0())) -> false()
     even(s(s(x))) -> even(x)
     half(0()) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(0(),y) -> 0()
     times(s(x),y) -> if_times(even(s(x)),s(x),y)
     if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
     if_times(false(),s(x),y) -> plus(y,times(x,y))
    Subterm Criterion Processor:
     simple projection:
      pi(half#) = 0
     problem:
      DPs:
       
      TRS:
       even(0()) -> true()
       even(s(0())) -> false()
       even(s(s(x))) -> even(x)
       half(0()) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(0(),y) -> 0()
       times(s(x),y) -> if_times(even(s(x)),s(x),y)
       if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
       if_times(false(),s(x),y) -> plus(y,times(x,y))
     Qed
    
    DPs:
     even#(s(s(x))) -> even#(x)
    TRS:
     even(0()) -> true()
     even(s(0())) -> false()
     even(s(s(x))) -> even(x)
     half(0()) -> 0()
     half(s(s(x))) -> s(half(x))
     plus(0(),y) -> y
     plus(s(x),y) -> s(plus(x,y))
     times(0(),y) -> 0()
     times(s(x),y) -> if_times(even(s(x)),s(x),y)
     if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
     if_times(false(),s(x),y) -> plus(y,times(x,y))
    Subterm Criterion Processor:
     simple projection:
      pi(even#) = 0
     problem:
      DPs:
       
      TRS:
       even(0()) -> true()
       even(s(0())) -> false()
       even(s(s(x))) -> even(x)
       half(0()) -> 0()
       half(s(s(x))) -> s(half(x))
       plus(0(),y) -> y
       plus(s(x),y) -> s(plus(x,y))
       times(0(),y) -> 0()
       times(s(x),y) -> if_times(even(s(x)),s(x),y)
       if_times(true(),s(x),y) -> plus(times(half(s(x)),y),times(half(s(x)),y))
       if_times(false(),s(x),y) -> plus(y,times(x,y))
     Qed