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


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


NO

Problem:
 nats() -> adx(zeros())
 zeros() -> cons(n__0(),n__zeros())
 incr(cons(X,Y)) -> cons(n__s(activate(X)),n__incr(activate(Y)))
 adx(cons(X,Y)) -> incr(cons(activate(X),n__adx(activate(Y))))
 hd(cons(X,Y)) -> activate(X)
 tl(cons(X,Y)) -> activate(Y)
 0() -> n__0()
 zeros() -> n__zeros()
 s(X) -> n__s(X)
 incr(X) -> n__incr(X)
 adx(X) -> n__adx(X)
 activate(n__0()) -> 0()
 activate(n__zeros()) -> zeros()
 activate(n__s(X)) -> s(X)
 activate(n__incr(X)) -> incr(activate(X))
 activate(n__adx(X)) -> adx(activate(X))
 activate(X) -> X

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [s](x0) = x0,
   
   [0] = 0,
   
   [tl](x0) = x0 + 7,
   
   [hd](x0) = 6x0,
   
   [n__adx](x0) = x0,
   
   [n__incr](x0) = x0,
   
   [n__s](x0) = x0,
   
   [activate](x0) = x0,
   
   [incr](x0) = x0,
   
   [cons](x0, x1) = 4x0 + x1,
   
   [n__zeros] = 0,
   
   [n__0] = 0,
   
   [adx](x0) = x0,
   
   [zeros] = 0,
   
   [nats] = 0
  orientation:
   nats() = 0 >= 0 = adx(zeros())
   
   zeros() = 0 >= 0 = cons(n__0(),n__zeros())
   
   incr(cons(X,Y)) = 4X + Y >= 4X + Y = cons(n__s(activate(X)),n__incr(activate(Y)))
   
   adx(cons(X,Y)) = 4X + Y >= 4X + Y = incr(cons(activate(X),n__adx(activate(Y))))
   
   hd(cons(X,Y)) = 24X + 6Y >= X = activate(X)
   
   tl(cons(X,Y)) = 4X + Y + 7 >= Y = activate(Y)
   
   0() = 0 >= 0 = n__0()
   
   zeros() = 0 >= 0 = n__zeros()
   
   s(X) = X >= X = n__s(X)
   
   incr(X) = X >= X = n__incr(X)
   
   adx(X) = X >= X = n__adx(X)
   
   activate(n__0()) = 0 >= 0 = 0()
   
   activate(n__zeros()) = 0 >= 0 = zeros()
   
   activate(n__s(X)) = X >= X = s(X)
   
   activate(n__incr(X)) = X >= X = incr(activate(X))
   
   activate(n__adx(X)) = X >= X = adx(activate(X))
   
   activate(X) = X >= X = X
  problem:
   nats() -> adx(zeros())
   zeros() -> cons(n__0(),n__zeros())
   incr(cons(X,Y)) -> cons(n__s(activate(X)),n__incr(activate(Y)))
   adx(cons(X,Y)) -> incr(cons(activate(X),n__adx(activate(Y))))
   hd(cons(X,Y)) -> activate(X)
   0() -> n__0()
   zeros() -> n__zeros()
   s(X) -> n__s(X)
   incr(X) -> n__incr(X)
   adx(X) -> n__adx(X)
   activate(n__0()) -> 0()
   activate(n__zeros()) -> zeros()
   activate(n__s(X)) -> s(X)
   activate(n__incr(X)) -> incr(activate(X))
   activate(n__adx(X)) -> adx(activate(X))
   activate(X) -> X
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [s](x0) = x0,
    
    [0] = 0,
    
    [hd](x0) = x0,
    
    [n__adx](x0) = x0,
    
    [n__incr](x0) = x0,
    
    [n__s](x0) = x0,
    
    [activate](x0) = x0,
    
    [incr](x0) = x0,
    
    [cons](x0, x1) = 2x0 + 2x1,
    
    [n__zeros] = 0,
    
    [n__0] = 0,
    
    [adx](x0) = x0,
    
    [zeros] = 0,
    
    [nats] = 4
   orientation:
    nats() = 4 >= 0 = adx(zeros())
    
    zeros() = 0 >= 0 = cons(n__0(),n__zeros())
    
    incr(cons(X,Y)) = 2X + 2Y >= 2X + 2Y = cons(n__s(activate(X)),n__incr(activate(Y)))
    
    adx(cons(X,Y)) = 2X + 2Y >= 2X + 2Y = incr(cons(activate(X),n__adx(activate(Y))))
    
    hd(cons(X,Y)) = 2X + 2Y >= X = activate(X)
    
    0() = 0 >= 0 = n__0()
    
    zeros() = 0 >= 0 = n__zeros()
    
    s(X) = X >= X = n__s(X)
    
    incr(X) = X >= X = n__incr(X)
    
    adx(X) = X >= X = n__adx(X)
    
    activate(n__0()) = 0 >= 0 = 0()
    
    activate(n__zeros()) = 0 >= 0 = zeros()
    
    activate(n__s(X)) = X >= X = s(X)
    
    activate(n__incr(X)) = X >= X = incr(activate(X))
    
    activate(n__adx(X)) = X >= X = adx(activate(X))
    
    activate(X) = X >= X = X
   problem:
    zeros() -> cons(n__0(),n__zeros())
    incr(cons(X,Y)) -> cons(n__s(activate(X)),n__incr(activate(Y)))
    adx(cons(X,Y)) -> incr(cons(activate(X),n__adx(activate(Y))))
    hd(cons(X,Y)) -> activate(X)
    0() -> n__0()
    zeros() -> n__zeros()
    s(X) -> n__s(X)
    incr(X) -> n__incr(X)
    adx(X) -> n__adx(X)
    activate(n__0()) -> 0()
    activate(n__zeros()) -> zeros()
    activate(n__s(X)) -> s(X)
    activate(n__incr(X)) -> incr(activate(X))
    activate(n__adx(X)) -> adx(activate(X))
    activate(X) -> X
   Matrix Interpretation Processor: dim=1
    
    interpretation:
     [s](x0) = x0,
     
     [0] = 0,
     
     [hd](x0) = x0 + 2,
     
     [n__adx](x0) = x0,
     
     [n__incr](x0) = x0,
     
     [n__s](x0) = x0,
     
     [activate](x0) = x0,
     
     [incr](x0) = x0,
     
     [cons](x0, x1) = x0 + x1,
     
     [n__zeros] = 1,
     
     [n__0] = 0,
     
     [adx](x0) = x0,
     
     [zeros] = 1
    orientation:
     zeros() = 1 >= 1 = cons(n__0(),n__zeros())
     
     incr(cons(X,Y)) = X + Y >= X + Y = cons(n__s(activate(X)),n__incr(activate(Y)))
     
     adx(cons(X,Y)) = X + Y >= X + Y = incr(cons(activate(X),n__adx(activate(Y))))
     
     hd(cons(X,Y)) = X + Y + 2 >= X = activate(X)
     
     0() = 0 >= 0 = n__0()
     
     zeros() = 1 >= 1 = n__zeros()
     
     s(X) = X >= X = n__s(X)
     
     incr(X) = X >= X = n__incr(X)
     
     adx(X) = X >= X = n__adx(X)
     
     activate(n__0()) = 0 >= 0 = 0()
     
     activate(n__zeros()) = 1 >= 1 = zeros()
     
     activate(n__s(X)) = X >= X = s(X)
     
     activate(n__incr(X)) = X >= X = incr(activate(X))
     
     activate(n__adx(X)) = X >= X = adx(activate(X))
     
     activate(X) = X >= X = X
    problem:
     zeros() -> cons(n__0(),n__zeros())
     incr(cons(X,Y)) -> cons(n__s(activate(X)),n__incr(activate(Y)))
     adx(cons(X,Y)) -> incr(cons(activate(X),n__adx(activate(Y))))
     0() -> n__0()
     zeros() -> n__zeros()
     s(X) -> n__s(X)
     incr(X) -> n__incr(X)
     adx(X) -> n__adx(X)
     activate(n__0()) -> 0()
     activate(n__zeros()) -> zeros()
     activate(n__s(X)) -> s(X)
     activate(n__incr(X)) -> incr(activate(X))
     activate(n__adx(X)) -> adx(activate(X))
     activate(X) -> X
    Unfolding Processor:
     loop length: 6
     terms:
      incr(cons(X,n__adx(n__zeros())))
      cons(n__s(activate(X)),n__incr(activate(n__adx(n__zeros()))))
      cons(n__s(activate(X)),n__incr(adx(activate(n__zeros()))))
      cons(n__s(activate(X)),n__incr(adx(zeros())))
      cons(n__s(activate(X)),n__incr(adx(cons(n__0(),n__zeros()))))
      cons(n__s(activate(X)),n__incr(incr(cons(activate(n__0()),n__adx(activate(n__zeros()))))))
     context: cons(n__s(activate(X)),n__incr([]))
     substitution:
      X -> activate(n__0())
     Qed