/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:
 pairNs() -> cons(0(),n__incr(oddNs()))
 oddNs() -> incr(pairNs())
 incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
 take(0(),XS) -> nil()
 take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
 zip(nil(),XS) -> nil()
 zip(X,nil()) -> nil()
 zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
 tail(cons(X,XS)) -> activate(XS)
 repItems(nil()) -> nil()
 repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
 incr(X) -> n__incr(X)
 take(X1,X2) -> n__take(X1,X2)
 zip(X1,X2) -> n__zip(X1,X2)
 cons(X1,X2) -> n__cons(X1,X2)
 repItems(X) -> n__repItems(X)
 activate(n__incr(X)) -> incr(X)
 activate(n__take(X1,X2)) -> take(X1,X2)
 activate(n__zip(X1,X2)) -> zip(X1,X2)
 activate(n__cons(X1,X2)) -> cons(X1,X2)
 activate(n__repItems(X)) -> repItems(X)
 activate(X) -> X

Proof:
 Matrix Interpretation Processor: dim=1
  
  interpretation:
   [n__cons](x0, x1) = x0 + x1,
   
   [n__repItems](x0) = x0,
   
   [repItems](x0) = 5x0,
   
   [tail](x0) = 2x0 + 4,
   
   [n__zip](x0, x1) = x0 + x1,
   
   [pair](x0, x1) = x0 + 5x1,
   
   [zip](x0, x1) = 5x0 + 5x1,
   
   [n__take](x0, x1) = 2x0 + x1,
   
   [nil] = 0,
   
   [take](x0, x1) = 2x0 + 5x1,
   
   [activate](x0) = 5x0,
   
   [s](x0) = 4x0,
   
   [incr](x0) = 5x0,
   
   [cons](x0, x1) = x0 + 4x1,
   
   [n__incr](x0) = x0,
   
   [oddNs] = 0,
   
   [0] = 0,
   
   [pairNs] = 0
  orientation:
   pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
   
   oddNs() = 0 >= 0 = incr(pairNs())
   
   incr(cons(X,XS)) = 5X + 20XS >= 4X + 20XS = cons(s(X),n__incr(activate(XS)))
   
   take(0(),XS) = 5XS >= 0 = nil()
   
   take(s(N),cons(X,XS)) = 8N + 5X + 20XS >= 8N + X + 20XS = cons(X,n__take(N,activate(XS)))
   
   zip(nil(),XS) = 5XS >= 0 = nil()
   
   zip(X,nil()) = 5X >= 0 = nil()
   
   zip(cons(X,XS),cons(Y,YS)) = 5X + 20XS + 5Y + 20YS >= X + 20XS + 5Y + 20YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
   
   tail(cons(X,XS)) = 2X + 8XS + 4 >= 5XS = activate(XS)
   
   repItems(nil()) = 0 >= 0 = nil()
   
   repItems(cons(X,XS)) = 5X + 20XS >= 5X + 20XS = cons(X,n__cons(X,n__repItems(activate(XS))))
   
   incr(X) = 5X >= X = n__incr(X)
   
   take(X1,X2) = 2X1 + 5X2 >= 2X1 + X2 = n__take(X1,X2)
   
   zip(X1,X2) = 5X1 + 5X2 >= X1 + X2 = n__zip(X1,X2)
   
   cons(X1,X2) = X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
   
   repItems(X) = 5X >= X = n__repItems(X)
   
   activate(n__incr(X)) = 5X >= 5X = incr(X)
   
   activate(n__take(X1,X2)) = 10X1 + 5X2 >= 2X1 + 5X2 = take(X1,X2)
   
   activate(n__zip(X1,X2)) = 5X1 + 5X2 >= 5X1 + 5X2 = zip(X1,X2)
   
   activate(n__cons(X1,X2)) = 5X1 + 5X2 >= X1 + 4X2 = cons(X1,X2)
   
   activate(n__repItems(X)) = 5X >= 5X = repItems(X)
   
   activate(X) = 5X >= X = X
  problem:
   pairNs() -> cons(0(),n__incr(oddNs()))
   oddNs() -> incr(pairNs())
   incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
   take(0(),XS) -> nil()
   take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
   zip(nil(),XS) -> nil()
   zip(X,nil()) -> nil()
   zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
   repItems(nil()) -> nil()
   repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
   incr(X) -> n__incr(X)
   take(X1,X2) -> n__take(X1,X2)
   zip(X1,X2) -> n__zip(X1,X2)
   cons(X1,X2) -> n__cons(X1,X2)
   repItems(X) -> n__repItems(X)
   activate(n__incr(X)) -> incr(X)
   activate(n__take(X1,X2)) -> take(X1,X2)
   activate(n__zip(X1,X2)) -> zip(X1,X2)
   activate(n__cons(X1,X2)) -> cons(X1,X2)
   activate(n__repItems(X)) -> repItems(X)
   activate(X) -> X
  Matrix Interpretation Processor: dim=1
   
   interpretation:
    [n__cons](x0, x1) = x0 + x1,
    
    [n__repItems](x0) = x0,
    
    [repItems](x0) = 4x0,
    
    [n__zip](x0, x1) = x0 + x1,
    
    [pair](x0, x1) = 4x0 + 2x1,
    
    [zip](x0, x1) = 4x0 + 4x1,
    
    [n__take](x0, x1) = x0 + x1 + 1,
    
    [nil] = 0,
    
    [take](x0, x1) = x0 + 4x1 + 4,
    
    [activate](x0) = 4x0,
    
    [s](x0) = 4x0,
    
    [incr](x0) = 4x0,
    
    [cons](x0, x1) = 4x0 + 4x1,
    
    [n__incr](x0) = x0,
    
    [oddNs] = 0,
    
    [0] = 0,
    
    [pairNs] = 0
   orientation:
    pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
    
    oddNs() = 0 >= 0 = incr(pairNs())
    
    incr(cons(X,XS)) = 16X + 16XS >= 16X + 16XS = cons(s(X),n__incr(activate(XS)))
    
    take(0(),XS) = 4XS + 4 >= 0 = nil()
    
    take(s(N),cons(X,XS)) = 4N + 16X + 16XS + 4 >= 4N + 4X + 16XS + 4 = cons(X,n__take(N,activate(XS)))
    
    zip(nil(),XS) = 4XS >= 0 = nil()
    
    zip(X,nil()) = 4X >= 0 = nil()
    
    zip(cons(X,XS),cons(Y,YS)) = 16X + 16XS + 16Y + 16YS >= 16X + 16XS + 8Y + 16YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
    
    repItems(nil()) = 0 >= 0 = nil()
    
    repItems(cons(X,XS)) = 16X + 16XS >= 8X + 16XS = cons(X,n__cons(X,n__repItems(activate(XS))))
    
    incr(X) = 4X >= X = n__incr(X)
    
    take(X1,X2) = X1 + 4X2 + 4 >= X1 + X2 + 1 = n__take(X1,X2)
    
    zip(X1,X2) = 4X1 + 4X2 >= X1 + X2 = n__zip(X1,X2)
    
    cons(X1,X2) = 4X1 + 4X2 >= X1 + X2 = n__cons(X1,X2)
    
    repItems(X) = 4X >= X = n__repItems(X)
    
    activate(n__incr(X)) = 4X >= 4X = incr(X)
    
    activate(n__take(X1,X2)) = 4X1 + 4X2 + 4 >= X1 + 4X2 + 4 = take(X1,X2)
    
    activate(n__zip(X1,X2)) = 4X1 + 4X2 >= 4X1 + 4X2 = zip(X1,X2)
    
    activate(n__cons(X1,X2)) = 4X1 + 4X2 >= 4X1 + 4X2 = cons(X1,X2)
    
    activate(n__repItems(X)) = 4X >= 4X = repItems(X)
    
    activate(X) = 4X >= X = X
   problem:
    pairNs() -> cons(0(),n__incr(oddNs()))
    oddNs() -> incr(pairNs())
    incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
    take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
    zip(nil(),XS) -> nil()
    zip(X,nil()) -> nil()
    zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
    repItems(nil()) -> nil()
    repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
    incr(X) -> n__incr(X)
    zip(X1,X2) -> n__zip(X1,X2)
    cons(X1,X2) -> n__cons(X1,X2)
    repItems(X) -> n__repItems(X)
    activate(n__incr(X)) -> incr(X)
    activate(n__take(X1,X2)) -> take(X1,X2)
    activate(n__zip(X1,X2)) -> zip(X1,X2)
    activate(n__cons(X1,X2)) -> cons(X1,X2)
    activate(n__repItems(X)) -> repItems(X)
    activate(X) -> X
   Matrix Interpretation Processor: dim=1
    
    interpretation:
     [n__cons](x0, x1) = x0 + x1,
     
     [n__repItems](x0) = 2x0,
     
     [repItems](x0) = 4x0,
     
     [n__zip](x0, x1) = x0 + 2x1 + 3,
     
     [pair](x0, x1) = x0 + 4x1,
     
     [zip](x0, x1) = 2x0 + 4x1 + 6,
     
     [n__take](x0, x1) = 4x0 + 2x1 + 1,
     
     [nil] = 0,
     
     [take](x0, x1) = 5x0 + 4x1 + 2,
     
     [activate](x0) = 2x0,
     
     [s](x0) = 2x0,
     
     [incr](x0) = 2x0,
     
     [cons](x0, x1) = x0 + 2x1,
     
     [n__incr](x0) = x0,
     
     [oddNs] = 0,
     
     [0] = 0,
     
     [pairNs] = 0
    orientation:
     pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
     
     oddNs() = 0 >= 0 = incr(pairNs())
     
     incr(cons(X,XS)) = 2X + 4XS >= 2X + 4XS = cons(s(X),n__incr(activate(XS)))
     
     take(s(N),cons(X,XS)) = 10N + 4X + 8XS + 2 >= 8N + X + 8XS + 2 = cons(X,n__take(N,activate(XS)))
     
     zip(nil(),XS) = 4XS + 6 >= 0 = nil()
     
     zip(X,nil()) = 2X + 6 >= 0 = nil()
     
     zip(cons(X,XS),cons(Y,YS)) = 2X + 4XS + 4Y + 8YS + 6 >= X + 4XS + 4Y + 8YS + 6 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
     
     repItems(nil()) = 0 >= 0 = nil()
     
     repItems(cons(X,XS)) = 4X + 8XS >= 3X + 8XS = cons(X,n__cons(X,n__repItems(activate(XS))))
     
     incr(X) = 2X >= X = n__incr(X)
     
     zip(X1,X2) = 2X1 + 4X2 + 6 >= X1 + 2X2 + 3 = n__zip(X1,X2)
     
     cons(X1,X2) = X1 + 2X2 >= X1 + X2 = n__cons(X1,X2)
     
     repItems(X) = 4X >= 2X = n__repItems(X)
     
     activate(n__incr(X)) = 2X >= 2X = incr(X)
     
     activate(n__take(X1,X2)) = 8X1 + 4X2 + 2 >= 5X1 + 4X2 + 2 = take(X1,X2)
     
     activate(n__zip(X1,X2)) = 2X1 + 4X2 + 6 >= 2X1 + 4X2 + 6 = zip(X1,X2)
     
     activate(n__cons(X1,X2)) = 2X1 + 2X2 >= X1 + 2X2 = cons(X1,X2)
     
     activate(n__repItems(X)) = 4X >= 4X = repItems(X)
     
     activate(X) = 2X >= X = X
    problem:
     pairNs() -> cons(0(),n__incr(oddNs()))
     oddNs() -> incr(pairNs())
     incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
     take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
     zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
     repItems(nil()) -> nil()
     repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
     incr(X) -> n__incr(X)
     cons(X1,X2) -> n__cons(X1,X2)
     repItems(X) -> n__repItems(X)
     activate(n__incr(X)) -> incr(X)
     activate(n__take(X1,X2)) -> take(X1,X2)
     activate(n__zip(X1,X2)) -> zip(X1,X2)
     activate(n__cons(X1,X2)) -> cons(X1,X2)
     activate(n__repItems(X)) -> repItems(X)
     activate(X) -> X
    Matrix Interpretation Processor: dim=1
     
     interpretation:
      [n__cons](x0, x1) = x0 + x1,
      
      [n__repItems](x0) = 2x0 + 4,
      
      [repItems](x0) = 2x0 + 4,
      
      [n__zip](x0, x1) = x0 + 4x1 + 6,
      
      [pair](x0, x1) = x0 + 4x1,
      
      [zip](x0, x1) = x0 + 4x1 + 6,
      
      [n__take](x0, x1) = x0 + x1 + 4,
      
      [nil] = 6,
      
      [take](x0, x1) = x0 + x1 + 4,
      
      [activate](x0) = x0,
      
      [s](x0) = x0,
      
      [incr](x0) = x0,
      
      [cons](x0, x1) = x0 + x1,
      
      [n__incr](x0) = x0,
      
      [oddNs] = 1,
      
      [0] = 0,
      
      [pairNs] = 1
     orientation:
      pairNs() = 1 >= 1 = cons(0(),n__incr(oddNs()))
      
      oddNs() = 1 >= 1 = incr(pairNs())
      
      incr(cons(X,XS)) = X + XS >= X + XS = cons(s(X),n__incr(activate(XS)))
      
      take(s(N),cons(X,XS)) = N + X + XS + 4 >= N + X + XS + 4 = cons(X,n__take(N,activate(XS)))
      
      zip(cons(X,XS),cons(Y,YS)) = X + XS + 4Y + 4YS + 6 >= X + XS + 4Y + 4YS + 6 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
      
      repItems(nil()) = 16 >= 6 = nil()
      
      repItems(cons(X,XS)) = 2X + 2XS + 4 >= 2X + 2XS + 4 = cons(X,n__cons(X,n__repItems(activate(XS))))
      
      incr(X) = X >= X = n__incr(X)
      
      cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
      
      repItems(X) = 2X + 4 >= 2X + 4 = n__repItems(X)
      
      activate(n__incr(X)) = X >= X = incr(X)
      
      activate(n__take(X1,X2)) = X1 + X2 + 4 >= X1 + X2 + 4 = take(X1,X2)
      
      activate(n__zip(X1,X2)) = X1 + 4X2 + 6 >= X1 + 4X2 + 6 = zip(X1,X2)
      
      activate(n__cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2)
      
      activate(n__repItems(X)) = 2X + 4 >= 2X + 4 = repItems(X)
      
      activate(X) = X >= X = X
     problem:
      pairNs() -> cons(0(),n__incr(oddNs()))
      oddNs() -> incr(pairNs())
      incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
      take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
      zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
      repItems(cons(X,XS)) -> cons(X,n__cons(X,n__repItems(activate(XS))))
      incr(X) -> n__incr(X)
      cons(X1,X2) -> n__cons(X1,X2)
      repItems(X) -> n__repItems(X)
      activate(n__incr(X)) -> incr(X)
      activate(n__take(X1,X2)) -> take(X1,X2)
      activate(n__zip(X1,X2)) -> zip(X1,X2)
      activate(n__cons(X1,X2)) -> cons(X1,X2)
      activate(n__repItems(X)) -> repItems(X)
      activate(X) -> X
     Matrix Interpretation Processor: dim=1
      
      interpretation:
       [n__cons](x0, x1) = x0 + x1,
       
       [n__repItems](x0) = x0 + 1,
       
       [repItems](x0) = 2x0 + 2,
       
       [n__zip](x0, x1) = x0 + x1,
       
       [pair](x0, x1) = 2x0 + 2x1,
       
       [zip](x0, x1) = 2x0 + 2x1,
       
       [n__take](x0, x1) = x0 + x1,
       
       [take](x0, x1) = x0 + 2x1,
       
       [activate](x0) = 2x0,
       
       [s](x0) = x0,
       
       [incr](x0) = 4x0,
       
       [cons](x0, x1) = x0 + x1,
       
       [n__incr](x0) = 2x0,
       
       [oddNs] = 0,
       
       [0] = 0,
       
       [pairNs] = 0
      orientation:
       pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
       
       oddNs() = 0 >= 0 = incr(pairNs())
       
       incr(cons(X,XS)) = 4X + 4XS >= X + 4XS = cons(s(X),n__incr(activate(XS)))
       
       take(s(N),cons(X,XS)) = N + 2X + 2XS >= N + X + 2XS = cons(X,n__take(N,activate(XS)))
       
       zip(cons(X,XS),cons(Y,YS)) = 2X + 2XS + 2Y + 2YS >= 2X + 2XS + 2Y + 2YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
       
       repItems(cons(X,XS)) = 2X + 2XS + 2 >= 2X + 2XS + 1 = cons(X,n__cons(X,n__repItems(activate(XS))))
       
       incr(X) = 4X >= 2X = n__incr(X)
       
       cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
       
       repItems(X) = 2X + 2 >= X + 1 = n__repItems(X)
       
       activate(n__incr(X)) = 4X >= 4X = incr(X)
       
       activate(n__take(X1,X2)) = 2X1 + 2X2 >= X1 + 2X2 = take(X1,X2)
       
       activate(n__zip(X1,X2)) = 2X1 + 2X2 >= 2X1 + 2X2 = zip(X1,X2)
       
       activate(n__cons(X1,X2)) = 2X1 + 2X2 >= X1 + X2 = cons(X1,X2)
       
       activate(n__repItems(X)) = 2X + 2 >= 2X + 2 = repItems(X)
       
       activate(X) = 2X >= X = X
      problem:
       pairNs() -> cons(0(),n__incr(oddNs()))
       oddNs() -> incr(pairNs())
       incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
       take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
       zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
       incr(X) -> n__incr(X)
       cons(X1,X2) -> n__cons(X1,X2)
       activate(n__incr(X)) -> incr(X)
       activate(n__take(X1,X2)) -> take(X1,X2)
       activate(n__zip(X1,X2)) -> zip(X1,X2)
       activate(n__cons(X1,X2)) -> cons(X1,X2)
       activate(n__repItems(X)) -> repItems(X)
       activate(X) -> X
      Matrix Interpretation Processor: dim=1
       
       interpretation:
        [n__cons](x0, x1) = x0 + x1,
        
        [n__repItems](x0) = x0 + 4,
        
        [repItems](x0) = x0,
        
        [n__zip](x0, x1) = 2x0 + 2x1 + 4,
        
        [pair](x0, x1) = 2x0 + 2x1,
        
        [zip](x0, x1) = 2x0 + 2x1 + 4,
        
        [n__take](x0, x1) = x0 + x1 + 5,
        
        [take](x0, x1) = x0 + x1 + 5,
        
        [activate](x0) = x0,
        
        [s](x0) = x0,
        
        [incr](x0) = x0,
        
        [cons](x0, x1) = x0 + x1,
        
        [n__incr](x0) = x0,
        
        [oddNs] = 0,
        
        [0] = 0,
        
        [pairNs] = 0
       orientation:
        pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
        
        oddNs() = 0 >= 0 = incr(pairNs())
        
        incr(cons(X,XS)) = X + XS >= X + XS = cons(s(X),n__incr(activate(XS)))
        
        take(s(N),cons(X,XS)) = N + X + XS + 5 >= N + X + XS + 5 = cons(X,n__take(N,activate(XS)))
        
        zip(cons(X,XS),cons(Y,YS)) = 2X + 2XS + 2Y + 2YS + 4 >= 2X + 2XS + 2Y + 2YS + 4 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
        
        incr(X) = X >= X = n__incr(X)
        
        cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
        
        activate(n__incr(X)) = X >= X = incr(X)
        
        activate(n__take(X1,X2)) = X1 + X2 + 5 >= X1 + X2 + 5 = take(X1,X2)
        
        activate(n__zip(X1,X2)) = 2X1 + 2X2 + 4 >= 2X1 + 2X2 + 4 = zip(X1,X2)
        
        activate(n__cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2)
        
        activate(n__repItems(X)) = X + 4 >= X = repItems(X)
        
        activate(X) = X >= X = X
       problem:
        pairNs() -> cons(0(),n__incr(oddNs()))
        oddNs() -> incr(pairNs())
        incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
        take(s(N),cons(X,XS)) -> cons(X,n__take(N,activate(XS)))
        zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
        incr(X) -> n__incr(X)
        cons(X1,X2) -> n__cons(X1,X2)
        activate(n__incr(X)) -> incr(X)
        activate(n__take(X1,X2)) -> take(X1,X2)
        activate(n__zip(X1,X2)) -> zip(X1,X2)
        activate(n__cons(X1,X2)) -> cons(X1,X2)
        activate(X) -> X
       Matrix Interpretation Processor: dim=3
        
        interpretation:
                             [1 0 0]     [1 1 0]  
         [n__cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1
                             [0 0 0]     [0 0 0]  ,
         
                            [1 0 0]     [1 0 0]     [0]
         [n__zip](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1]
                            [0 0 0]     [0 0 0]     [0],
         
                          [1 0 0]     [1 0 0]  
         [pair](x0, x1) = [0 0 0]x0 + [0 0 0]x1
                          [0 0 0]     [0 0 0]  ,
         
                         [1 0 0]     [1 0 0]     [1]
         [zip](x0, x1) = [1 0 0]x0 + [0 0 0]x1 + [0]
                         [1 0 0]     [1 0 0]     [0],
         
                             [1 0 1]     [1 0 0]  
         [n__take](x0, x1) = [0 0 0]x0 + [0 0 0]x1
                             [0 1 0]     [0 0 0]  ,
         
                          [1 0 1]     [1 0 0]  
         [take](x0, x1) = [0 0 0]x0 + [1 0 0]x1
                          [0 1 1]     [1 0 0]  ,
         
                          [1 1 0]  
         [activate](x0) = [1 1 0]x0
                          [1 0 1]  ,
         
                   [1 0 0]     [0]
         [s](x0) = [1 0 0]x0 + [0]
                   [0 0 1]     [1],
         
                      [1 0 0]  
         [incr](x0) = [0 0 0]x0
                      [1 1 0]  ,
         
                          [1 0 0]     [1 1 0]  
         [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1
                          [0 0 0]     [1 0 0]  ,
         
                         [1 0 0]  
         [n__incr](x0) = [0 0 0]x0
                         [0 1 0]  ,
         
                   [0]
         [oddNs] = [1]
                   [0],
         
               [0]
         [0] = [0]
               [0],
         
                    [0]
         [pairNs] = [0]
                    [0]
        orientation:
                    [0]    [0]                             
         pairNs() = [0] >= [0] = cons(0(),n__incr(oddNs()))
                    [0]    [0]                             
         
                   [0]    [0]                 
         oddNs() = [1] >= [0] = incr(pairNs())
                   [0]    [0]                 
         
                            [1 0 0]    [1 1 0]      [1 0 0]    [1 1 0]                                     
         incr(cons(X,XS)) = [0 0 0]X + [0 0 0]XS >= [0 0 0]X + [0 0 0]XS = cons(s(X),n__incr(activate(XS)))
                            [1 0 0]    [1 1 0]      [0 0 0]    [1 1 0]                                     
         
                                 [1 0 1]    [1 0 0]    [1 1 0]     [1]    [1 0 1]    [1 0 0]    [1 1 0]                                    
         take(s(N),cons(X,XS)) = [0 0 0]N + [1 0 0]X + [1 1 0]XS + [0] >= [0 0 0]N + [0 0 0]X + [0 0 0]XS = cons(X,n__take(N,activate(XS)))
                                 [1 0 1]    [1 0 0]    [1 1 0]     [1]    [1 0 1]    [0 0 0]    [1 1 0]                                    
         
                                      [1 0 0]    [1 1 0]     [1 0 0]    [1 1 0]     [1]    [1 0 0]    [1 1 0]     [1 0 0]    [1 1 0]     [1]                                                    
         zip(cons(X,XS),cons(Y,YS)) = [1 0 0]X + [1 1 0]XS + [0 0 0]Y + [0 0 0]YS + [0] >= [0 0 0]X + [0 0 0]XS + [0 0 0]Y + [0 0 0]YS + [0] = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
                                      [1 0 0]    [1 1 0]     [1 0 0]    [1 1 0]     [0]    [0 0 0]    [1 1 0]     [0 0 0]    [1 1 0]     [0]                                                    
         
                   [1 0 0]     [1 0 0]              
         incr(X) = [0 0 0]X >= [0 0 0]X = n__incr(X)
                   [1 1 0]     [0 1 0]              
         
                       [1 0 0]     [1 1 0]      [1 0 0]     [1 1 0]                   
         cons(X1,X2) = [0 0 0]X1 + [0 0 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = n__cons(X1,X2)
                       [0 0 0]     [1 0 0]      [0 0 0]     [0 0 0]                   
         
                                [1 0 0]     [1 0 0]           
         activate(n__incr(X)) = [1 0 0]X >= [0 0 0]X = incr(X)
                                [1 1 0]     [1 1 0]           
         
                                    [1 0 1]     [1 0 0]      [1 0 1]     [1 0 0]                
         activate(n__take(X1,X2)) = [1 0 1]X1 + [1 0 0]X2 >= [0 0 0]X1 + [1 0 0]X2 = take(X1,X2)
                                    [1 1 1]     [1 0 0]      [0 1 1]     [1 0 0]                
         
                                   [1 0 0]     [1 0 0]     [1]    [1 0 0]     [1 0 0]     [1]             
         activate(n__zip(X1,X2)) = [1 0 0]X1 + [1 0 0]X2 + [1] >= [1 0 0]X1 + [0 0 0]X2 + [0] = zip(X1,X2)
                                   [1 0 0]     [1 0 0]     [0]    [1 0 0]     [1 0 0]     [0]             
         
                                    [1 0 0]     [1 1 0]      [1 0 0]     [1 1 0]                
         activate(n__cons(X1,X2)) = [1 0 0]X1 + [1 1 0]X2 >= [0 0 0]X1 + [0 0 0]X2 = cons(X1,X2)
                                    [1 0 0]     [1 1 0]      [0 0 0]     [1 0 0]                
         
                       [1 1 0]          
         activate(X) = [1 1 0]X >= X = X
                       [1 0 1]          
        problem:
         pairNs() -> cons(0(),n__incr(oddNs()))
         oddNs() -> incr(pairNs())
         incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
         zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
         incr(X) -> n__incr(X)
         cons(X1,X2) -> n__cons(X1,X2)
         activate(n__incr(X)) -> incr(X)
         activate(n__take(X1,X2)) -> take(X1,X2)
         activate(n__zip(X1,X2)) -> zip(X1,X2)
         activate(n__cons(X1,X2)) -> cons(X1,X2)
         activate(X) -> X
        Matrix Interpretation Processor: dim=1
         
         interpretation:
          [n__cons](x0, x1) = x0 + 4x1,
          
          [n__zip](x0, x1) = 4x0 + x1,
          
          [pair](x0, x1) = 2x0 + x1,
          
          [zip](x0, x1) = 4x0 + x1,
          
          [n__take](x0, x1) = 2x0 + 2x1 + 4,
          
          [take](x0, x1) = x0 + 2x1,
          
          [activate](x0) = x0,
          
          [s](x0) = x0,
          
          [incr](x0) = 4x0,
          
          [cons](x0, x1) = x0 + 4x1,
          
          [n__incr](x0) = 4x0,
          
          [oddNs] = 0,
          
          [0] = 0,
          
          [pairNs] = 0
         orientation:
          pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
          
          oddNs() = 0 >= 0 = incr(pairNs())
          
          incr(cons(X,XS)) = 4X + 16XS >= X + 16XS = cons(s(X),n__incr(activate(XS)))
          
          zip(cons(X,XS),cons(Y,YS)) = 4X + 16XS + Y + 4YS >= 2X + 16XS + Y + 4YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
          
          incr(X) = 4X >= 4X = n__incr(X)
          
          cons(X1,X2) = X1 + 4X2 >= X1 + 4X2 = n__cons(X1,X2)
          
          activate(n__incr(X)) = 4X >= 4X = incr(X)
          
          activate(n__take(X1,X2)) = 2X1 + 2X2 + 4 >= X1 + 2X2 = take(X1,X2)
          
          activate(n__zip(X1,X2)) = 4X1 + X2 >= 4X1 + X2 = zip(X1,X2)
          
          activate(n__cons(X1,X2)) = X1 + 4X2 >= X1 + 4X2 = cons(X1,X2)
          
          activate(X) = X >= X = X
         problem:
          pairNs() -> cons(0(),n__incr(oddNs()))
          oddNs() -> incr(pairNs())
          incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
          zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
          incr(X) -> n__incr(X)
          cons(X1,X2) -> n__cons(X1,X2)
          activate(n__incr(X)) -> incr(X)
          activate(n__zip(X1,X2)) -> zip(X1,X2)
          activate(n__cons(X1,X2)) -> cons(X1,X2)
          activate(X) -> X
         Matrix Interpretation Processor: dim=1
          
          interpretation:
           [n__cons](x0, x1) = 2x0 + x1,
           
           [n__zip](x0, x1) = 3x0 + x1 + 4,
           
           [pair](x0, x1) = 4x0 + 2x1,
           
           [zip](x0, x1) = 6x0 + 2x1 + 4,
           
           [activate](x0) = 2x0,
           
           [s](x0) = 2x0,
           
           [incr](x0) = 4x0,
           
           [cons](x0, x1) = 2x0 + x1,
           
           [n__incr](x0) = 2x0,
           
           [oddNs] = 0,
           
           [0] = 0,
           
           [pairNs] = 0
          orientation:
           pairNs() = 0 >= 0 = cons(0(),n__incr(oddNs()))
           
           oddNs() = 0 >= 0 = incr(pairNs())
           
           incr(cons(X,XS)) = 8X + 4XS >= 4X + 4XS = cons(s(X),n__incr(activate(XS)))
           
           zip(cons(X,XS),cons(Y,YS)) = 12X + 6XS + 4Y + 2YS + 4 >= 8X + 6XS + 4Y + 2YS + 4 = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
           
           incr(X) = 4X >= 2X = n__incr(X)
           
           cons(X1,X2) = 2X1 + X2 >= 2X1 + X2 = n__cons(X1,X2)
           
           activate(n__incr(X)) = 4X >= 4X = incr(X)
           
           activate(n__zip(X1,X2)) = 6X1 + 2X2 + 8 >= 6X1 + 2X2 + 4 = zip(X1,X2)
           
           activate(n__cons(X1,X2)) = 4X1 + 2X2 >= 2X1 + X2 = cons(X1,X2)
           
           activate(X) = 2X >= X = X
          problem:
           pairNs() -> cons(0(),n__incr(oddNs()))
           oddNs() -> incr(pairNs())
           incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
           zip(cons(X,XS),cons(Y,YS)) -> cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
           incr(X) -> n__incr(X)
           cons(X1,X2) -> n__cons(X1,X2)
           activate(n__incr(X)) -> incr(X)
           activate(n__cons(X1,X2)) -> cons(X1,X2)
           activate(X) -> X
          Matrix Interpretation Processor: dim=1
           
           interpretation:
            [n__cons](x0, x1) = x0 + x1,
            
            [n__zip](x0, x1) = 2x0 + x1,
            
            [pair](x0, x1) = x0 + x1,
            
            [zip](x0, x1) = 3x0 + 2x1 + 1,
            
            [activate](x0) = x0,
            
            [s](x0) = x0,
            
            [incr](x0) = x0,
            
            [cons](x0, x1) = x0 + x1,
            
            [n__incr](x0) = x0,
            
            [oddNs] = 5,
            
            [0] = 0,
            
            [pairNs] = 5
           orientation:
            pairNs() = 5 >= 5 = cons(0(),n__incr(oddNs()))
            
            oddNs() = 5 >= 5 = incr(pairNs())
            
            incr(cons(X,XS)) = X + XS >= X + XS = cons(s(X),n__incr(activate(XS)))
            
            zip(cons(X,XS),cons(Y,YS)) = 3X + 3XS + 2Y + 2YS + 1 >= X + 2XS + Y + YS = cons(pair(X,Y),n__zip(activate(XS),activate(YS)))
            
            incr(X) = X >= X = n__incr(X)
            
            cons(X1,X2) = X1 + X2 >= X1 + X2 = n__cons(X1,X2)
            
            activate(n__incr(X)) = X >= X = incr(X)
            
            activate(n__cons(X1,X2)) = X1 + X2 >= X1 + X2 = cons(X1,X2)
            
            activate(X) = X >= X = X
           problem:
            pairNs() -> cons(0(),n__incr(oddNs()))
            oddNs() -> incr(pairNs())
            incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
            incr(X) -> n__incr(X)
            cons(X1,X2) -> n__cons(X1,X2)
            activate(n__incr(X)) -> incr(X)
            activate(n__cons(X1,X2)) -> cons(X1,X2)
            activate(X) -> X
           Matrix Interpretation Processor: dim=3
            
            interpretation:
                                 [1 0 0]     [1 1 0]     [0]
             [n__cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1]
                                 [0 0 0]     [0 1 0]     [0],
             
                              [1 1 0]  
             [activate](x0) = [0 1 1]x0
                              [0 0 1]  ,
             
                       [1 0 0]  
             [s](x0) = [0 0 0]x0
                       [0 0 0]  ,
             
                          [1 0 0]     [0]
             [incr](x0) = [0 0 0]x0 + [1]
                          [1 0 0]     [1],
             
                              [1 0 0]     [1 1 0]     [0]
             [cons](x0, x1) = [0 0 0]x0 + [0 0 0]x1 + [1]
                              [0 0 0]     [0 1 0]     [0],
             
                             [1 0 0]     [0]
             [n__incr](x0) = [0 0 0]x0 + [0]
                             [1 0 0]     [1],
             
                       [0]
             [oddNs] = [1]
                       [1],
             
                   [0]
             [0] = [0]
                   [0],
             
                        [0]
             [pairNs] = [1]
                        [1]
            orientation:
                        [0]    [0]                             
             pairNs() = [1] >= [1] = cons(0(),n__incr(oddNs()))
                        [1]    [0]                             
             
                       [0]    [0]                 
             oddNs() = [1] >= [1] = incr(pairNs())
                       [1]    [1]                 
             
                                [1 0 0]    [1 1 0]     [0]    [1 0 0]    [1 1 0]     [0]                                   
             incr(cons(X,XS)) = [0 0 0]X + [0 0 0]XS + [1] >= [0 0 0]X + [0 0 0]XS + [1] = cons(s(X),n__incr(activate(XS)))
                                [1 0 0]    [1 1 0]     [1]    [0 0 0]    [0 0 0]     [0]                                   
             
                       [1 0 0]    [0]    [1 0 0]    [0]             
             incr(X) = [0 0 0]X + [1] >= [0 0 0]X + [0] = n__incr(X)
                       [1 0 0]    [1]    [1 0 0]    [1]             
             
                           [1 0 0]     [1 1 0]     [0]    [1 0 0]     [1 1 0]     [0]                 
             cons(X1,X2) = [0 0 0]X1 + [0 0 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = n__cons(X1,X2)
                           [0 0 0]     [0 1 0]     [0]    [0 0 0]     [0 1 0]     [0]                 
             
                                    [1 0 0]    [0]    [1 0 0]    [0]          
             activate(n__incr(X)) = [1 0 0]X + [1] >= [0 0 0]X + [1] = incr(X)
                                    [1 0 0]    [1]    [1 0 0]    [1]          
             
                                        [1 0 0]     [1 1 0]     [1]    [1 0 0]     [1 1 0]     [0]              
             activate(n__cons(X1,X2)) = [0 0 0]X1 + [0 1 0]X2 + [1] >= [0 0 0]X1 + [0 0 0]X2 + [1] = cons(X1,X2)
                                        [0 0 0]     [0 1 0]     [0]    [0 0 0]     [0 1 0]     [0]              
             
                           [1 1 0]          
             activate(X) = [0 1 1]X >= X = X
                           [0 0 1]          
            problem:
             pairNs() -> cons(0(),n__incr(oddNs()))
             oddNs() -> incr(pairNs())
             incr(cons(X,XS)) -> cons(s(X),n__incr(activate(XS)))
             incr(X) -> n__incr(X)
             cons(X1,X2) -> n__cons(X1,X2)
             activate(n__incr(X)) -> incr(X)
             activate(X) -> X
            Unfolding Processor:
             loop length: 2
             terms:
              pairNs()
              cons(0(),n__incr(oddNs()))
             context: cons(0(),n__incr(incr([])))
             substitution:
              
             Qed