YES

We show the termination of the TRS R:

  a__pairNs() -> cons(|0|(),incr(oddNs()))
  a__oddNs() -> a__incr(a__pairNs())
  a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
  a__take(|0|(),XS) -> nil()
  a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
  a__zip(nil(),XS) -> nil()
  a__zip(X,nil()) -> nil()
  a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
  a__tail(cons(X,XS)) -> mark(XS)
  a__repItems(nil()) -> nil()
  a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
  mark(pairNs()) -> a__pairNs()
  mark(incr(X)) -> a__incr(mark(X))
  mark(oddNs()) -> a__oddNs()
  mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
  mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
  mark(tail(X)) -> a__tail(mark(X))
  mark(repItems(X)) -> a__repItems(mark(X))
  mark(cons(X1,X2)) -> cons(mark(X1),X2)
  mark(|0|()) -> |0|()
  mark(s(X)) -> s(mark(X))
  mark(nil()) -> nil()
  mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
  a__pairNs() -> pairNs()
  a__incr(X) -> incr(X)
  a__oddNs() -> oddNs()
  a__take(X1,X2) -> take(X1,X2)
  a__zip(X1,X2) -> zip(X1,X2)
  a__tail(X) -> tail(X)
  a__repItems(X) -> repItems(X)

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__oddNs#() -> a__pairNs#()
p3: a__incr#(cons(X,XS)) -> mark#(X)
p4: a__take#(s(N),cons(X,XS)) -> mark#(X)
p5: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(X)
p6: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(Y)
p7: a__tail#(cons(X,XS)) -> mark#(XS)
p8: a__repItems#(cons(X,XS)) -> mark#(X)
p9: mark#(pairNs()) -> a__pairNs#()
p10: mark#(incr(X)) -> a__incr#(mark(X))
p11: mark#(incr(X)) -> mark#(X)
p12: mark#(oddNs()) -> a__oddNs#()
p13: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p14: mark#(take(X1,X2)) -> mark#(X1)
p15: mark#(take(X1,X2)) -> mark#(X2)
p16: mark#(zip(X1,X2)) -> a__zip#(mark(X1),mark(X2))
p17: mark#(zip(X1,X2)) -> mark#(X1)
p18: mark#(zip(X1,X2)) -> mark#(X2)
p19: mark#(tail(X)) -> a__tail#(mark(X))
p20: mark#(tail(X)) -> mark#(X)
p21: mark#(repItems(X)) -> a__repItems#(mark(X))
p22: mark#(repItems(X)) -> mark#(X)
p23: mark#(cons(X1,X2)) -> mark#(X1)
p24: mark#(s(X)) -> mark#(X)
p25: mark#(pair(X1,X2)) -> mark#(X1)
p26: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p3, p4, p5, p6, p7, p8, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(cons(X1,X2)) -> mark#(X1)
p7: mark#(repItems(X)) -> mark#(X)
p8: mark#(repItems(X)) -> a__repItems#(mark(X))
p9: a__repItems#(cons(X,XS)) -> mark#(X)
p10: mark#(tail(X)) -> mark#(X)
p11: mark#(tail(X)) -> a__tail#(mark(X))
p12: a__tail#(cons(X,XS)) -> mark#(XS)
p13: mark#(zip(X1,X2)) -> mark#(X2)
p14: mark#(zip(X1,X2)) -> mark#(X1)
p15: mark#(zip(X1,X2)) -> a__zip#(mark(X1),mark(X2))
p16: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(Y)
p17: mark#(take(X1,X2)) -> mark#(X2)
p18: mark#(take(X1,X2)) -> mark#(X1)
p19: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p20: a__take#(s(N),cons(X,XS)) -> mark#(X)
p21: mark#(oddNs()) -> a__oddNs#()
p22: mark#(incr(X)) -> mark#(X)
p23: mark#(incr(X)) -> a__incr#(mark(X))
p24: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (3,1)
            a__incr#_A(x1) = ((1,0),(1,0)) x1 + (2,0)
            a__pairNs_A() = (1,3)
            cons_A(x1,x2) = ((1,0),(1,0)) x1 + x2
            mark#_A(x1) = ((1,0),(1,0)) x1 + (2,0)
            pair_A(x1,x2) = x1 + ((1,0),(1,1)) x2 + (0,1)
            s_A(x1) = x1 + (0,2)
            repItems_A(x1) = ((1,1),(1,1)) x1 + (4,1)
            a__repItems#_A(x1) = x1 + (3,0)
            mark_A(x1) = x1
            tail_A(x1) = ((1,1),(0,1)) x1 + (3,1)
            a__tail#_A(x1) = ((1,0),(1,1)) x1 + (4,2)
            zip_A(x1,x2) = ((1,1),(1,0)) x1 + ((1,1),(1,0)) x2 + (4,1)
            a__zip#_A(x1,x2) = x1 + x2 + (3,0)
            take_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,1),(1,0)) x2 + (0,3)
            a__take#_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,1),(1,0)) x2 + (2,0)
            oddNs_A() = (1,2)
            incr_A(x1) = ((1,0),(1,0)) x1 + (0,1)
            a__oddNs_A() = (1,2)
            a__incr_A(x1) = ((1,0),(1,0)) x1 + (0,1)
            a__take_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,1),(1,0)) x2 + (0,3)
            |0|_A() = (0,4)
            nil_A() = (0,1)
            a__zip_A(x1,x2) = ((1,1),(1,0)) x1 + ((1,1),(1,0)) x2 + (4,1)
            a__tail_A(x1) = ((1,1),(0,1)) x1 + (3,1)
            a__repItems_A(x1) = ((1,1),(1,1)) x1 + (4,1)
            pairNs_A() = (1,3)
    
      precedence:
      
        pair = s = mark = zip = take = a__oddNs = a__take = a__zip > nil = a__repItems > repItems > tail = a__tail > a__tail# > oddNs > a__incr > a__pairNs > |0| = pairNs > a__oddNs# = a__incr# = cons = mark# = a__repItems# = a__zip# = a__take# = incr
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(pair) = []
        pi(s) = []
        pi(repItems) = []
        pi(a__repItems#) = [1]
        pi(mark) = []
        pi(tail) = []
        pi(a__tail#) = [1]
        pi(zip) = []
        pi(a__zip#) = [1]
        pi(take) = []
        pi(a__take#) = []
        pi(oddNs) = []
        pi(incr) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = [1]
        pi(a__repItems) = []
        pi(pairNs) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (4,2)
            a__incr#_A(x1) = (4,2)
            a__pairNs_A() = (2,2)
            cons_A(x1,x2) = (0,2)
            mark#_A(x1) = (4,2)
            pair_A(x1,x2) = (1,0)
            s_A(x1) = (3,2)
            repItems_A(x1) = (1,2)
            a__repItems#_A(x1) = ((0,0),(0,1)) x1 + (4,0)
            mark_A(x1) = (3,2)
            tail_A(x1) = (5,1)
            a__tail#_A(x1) = ((0,1),(0,1)) x1 + (2,0)
            zip_A(x1,x2) = (1,1)
            a__zip#_A(x1,x2) = ((0,1),(0,0)) x1 + (2,2)
            take_A(x1,x2) = (3,2)
            a__take#_A(x1,x2) = (4,2)
            oddNs_A() = (2,2)
            incr_A(x1) = (1,1)
            a__oddNs_A() = (3,2)
            a__incr_A(x1) = (2,2)
            a__take_A(x1,x2) = (3,2)
            |0|_A() = (4,3)
            nil_A() = (3,0)
            a__zip_A(x1,x2) = (3,2)
            a__tail_A(x1) = ((0,1),(0,0)) x1 + (6,2)
            a__repItems_A(x1) = (2,2)
            pairNs_A() = (1,1)
    
      precedence:
      
        a__tail# > a__oddNs# = a__incr# = mark# = a__repItems# = a__zip# = a__take# > mark = a__incr = a__take = a__zip = a__tail > tail > a__oddNs > oddNs > take > cons = repItems = a__repItems > a__pairNs > s = pairNs > incr > pair > |0| > zip = nil
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(pair) = []
        pi(s) = []
        pi(repItems) = []
        pi(a__repItems#) = []
        pi(mark) = []
        pi(tail) = []
        pi(a__tail#) = []
        pi(zip) = []
        pi(a__zip#) = []
        pi(take) = []
        pi(a__take#) = []
        pi(oddNs) = []
        pi(incr) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = []
        pi(a__repItems) = []
        pi(pairNs) = []
    

The next rules are strictly ordered:

  p11, p12

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(cons(X1,X2)) -> mark#(X1)
p7: mark#(repItems(X)) -> mark#(X)
p8: mark#(repItems(X)) -> a__repItems#(mark(X))
p9: a__repItems#(cons(X,XS)) -> mark#(X)
p10: mark#(tail(X)) -> mark#(X)
p11: mark#(zip(X1,X2)) -> mark#(X2)
p12: mark#(zip(X1,X2)) -> mark#(X1)
p13: mark#(zip(X1,X2)) -> a__zip#(mark(X1),mark(X2))
p14: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(Y)
p15: mark#(take(X1,X2)) -> mark#(X2)
p16: mark#(take(X1,X2)) -> mark#(X1)
p17: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p18: a__take#(s(N),cons(X,XS)) -> mark#(X)
p19: mark#(oddNs()) -> a__oddNs#()
p20: mark#(incr(X)) -> mark#(X)
p21: mark#(incr(X)) -> a__incr#(mark(X))
p22: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(incr(X)) -> a__incr#(mark(X))
p4: mark#(incr(X)) -> mark#(X)
p5: mark#(oddNs()) -> a__oddNs#()
p6: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p7: a__take#(s(N),cons(X,XS)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X1)
p9: mark#(take(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> a__zip#(mark(X1),mark(X2))
p11: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(X)
p12: mark#(zip(X1,X2)) -> mark#(X1)
p13: mark#(zip(X1,X2)) -> mark#(X2)
p14: mark#(tail(X)) -> mark#(X)
p15: mark#(repItems(X)) -> a__repItems#(mark(X))
p16: a__repItems#(cons(X,XS)) -> mark#(X)
p17: mark#(repItems(X)) -> mark#(X)
p18: mark#(cons(X1,X2)) -> mark#(X1)
p19: mark#(s(X)) -> mark#(X)
p20: mark#(pair(X1,X2)) -> mark#(X1)
p21: mark#(pair(X1,X2)) -> mark#(X2)
p22: a__zip#(cons(X,XS),cons(Y,YS)) -> mark#(Y)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (0,0)
            a__incr#_A(x1) = ((0,1),(1,0)) x1
            a__pairNs_A() = (0,0)
            cons_A(x1,x2) = ((0,1),(0,1)) x1 + x2
            mark#_A(x1) = ((0,1),(0,1)) x1
            incr_A(x1) = ((0,1),(1,1)) x1
            mark_A(x1) = x1
            oddNs_A() = (0,0)
            take_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (2,2)
            a__take#_A(x1,x2) = ((0,1),(0,0)) x1 + ((0,1),(0,1)) x2 + (1,1)
            s_A(x1) = ((1,1),(0,1)) x1 + (1,0)
            zip_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (2,2)
            a__zip#_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (1,1)
            tail_A(x1) = ((1,1),(0,1)) x1 + (1,1)
            repItems_A(x1) = ((1,1),(1,1)) x1 + (2,2)
            a__repItems#_A(x1) = ((1,0),(1,1)) x1 + (1,2)
            pair_A(x1,x2) = x1 + ((0,1),(0,1)) x2 + (3,0)
            a__oddNs_A() = (0,0)
            a__incr_A(x1) = ((0,1),(1,1)) x1
            a__take_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (2,2)
            |0|_A() = (1,0)
            nil_A() = (2,1)
            a__zip_A(x1,x2) = ((1,0),(1,1)) x1 + ((1,0),(1,1)) x2 + (2,2)
            a__tail_A(x1) = ((1,1),(0,1)) x1 + (1,1)
            a__repItems_A(x1) = ((1,1),(1,1)) x1 + (2,2)
            pairNs_A() = (0,0)
    
      precedence:
      
        oddNs = zip = a__oddNs = a__zip > a__pairNs = pairNs > incr = a__incr > cons = mark = s = tail = a__tail = a__repItems > a__take > a__oddNs# = a__incr# = mark# = take = a__take# = repItems = a__repItems# > |0| > nil > a__zip# > pair
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(incr) = []
        pi(mark) = [1]
        pi(oddNs) = []
        pi(take) = [1, 2]
        pi(a__take#) = []
        pi(s) = []
        pi(zip) = []
        pi(a__zip#) = [1, 2]
        pi(tail) = []
        pi(repItems) = [1]
        pi(a__repItems#) = []
        pi(pair) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = [1, 2]
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = []
        pi(a__repItems) = [1]
        pi(pairNs) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (11,2)
            a__incr#_A(x1) = (11,2)
            a__pairNs_A() = (0,0)
            cons_A(x1,x2) = (18,15)
            mark#_A(x1) = (11,2)
            incr_A(x1) = (12,2)
            mark_A(x1) = ((1,1),(1,1)) x1 + (3,6)
            oddNs_A() = (1,2)
            take_A(x1,x2) = x1 + (20,3)
            a__take#_A(x1,x2) = (11,2)
            s_A(x1) = (19,2)
            zip_A(x1,x2) = (2,15)
            a__zip#_A(x1,x2) = ((1,1),(1,1)) x2 + (1,0)
            tail_A(x1) = (1,1)
            repItems_A(x1) = ((1,0),(1,0)) x1 + (1,1)
            a__repItems#_A(x1) = (11,2)
            pair_A(x1,x2) = (12,2)
            a__oddNs_A() = (2,10)
            a__incr_A(x1) = (18,21)
            a__take_A(x1,x2) = x1 + (22,3)
            |0|_A() = (0,0)
            nil_A() = (1,1)
            a__zip_A(x1,x2) = (19,16)
            a__tail_A(x1) = (2,6)
            a__repItems_A(x1) = ((1,0),(0,0)) x1 + (3,15)
            pairNs_A() = (0,0)
    
      precedence:
      
        a__repItems > a__tail > tail = repItems = a__zip > zip > a__incr > a__pairNs = incr > cons = mark = s = a__take > a__oddNs > take > a__oddNs# = a__incr# = mark# = oddNs = a__take# = a__zip# = a__repItems# = pair = |0| = nil = pairNs
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(incr) = []
        pi(mark) = [1]
        pi(oddNs) = []
        pi(take) = []
        pi(a__take#) = []
        pi(s) = []
        pi(zip) = []
        pi(a__zip#) = [2]
        pi(tail) = []
        pi(repItems) = []
        pi(a__repItems#) = []
        pi(pair) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = []
        pi(a__repItems) = []
        pi(pairNs) = []
    

The next rules are strictly ordered:

  p10, p11, p22

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(incr(X)) -> a__incr#(mark(X))
p4: mark#(incr(X)) -> mark#(X)
p5: mark#(oddNs()) -> a__oddNs#()
p6: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p7: a__take#(s(N),cons(X,XS)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X1)
p9: mark#(take(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> mark#(X1)
p11: mark#(zip(X1,X2)) -> mark#(X2)
p12: mark#(tail(X)) -> mark#(X)
p13: mark#(repItems(X)) -> a__repItems#(mark(X))
p14: a__repItems#(cons(X,XS)) -> mark#(X)
p15: mark#(repItems(X)) -> mark#(X)
p16: mark#(cons(X1,X2)) -> mark#(X1)
p17: mark#(s(X)) -> mark#(X)
p18: mark#(pair(X1,X2)) -> mark#(X1)
p19: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(cons(X1,X2)) -> mark#(X1)
p7: mark#(repItems(X)) -> mark#(X)
p8: mark#(repItems(X)) -> a__repItems#(mark(X))
p9: a__repItems#(cons(X,XS)) -> mark#(X)
p10: mark#(tail(X)) -> mark#(X)
p11: mark#(zip(X1,X2)) -> mark#(X2)
p12: mark#(zip(X1,X2)) -> mark#(X1)
p13: mark#(take(X1,X2)) -> mark#(X2)
p14: mark#(take(X1,X2)) -> mark#(X1)
p15: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p16: a__take#(s(N),cons(X,XS)) -> mark#(X)
p17: mark#(oddNs()) -> a__oddNs#()
p18: mark#(incr(X)) -> mark#(X)
p19: mark#(incr(X)) -> a__incr#(mark(X))

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (1,0)
            a__incr#_A(x1) = ((1,0),(0,0)) x1
            a__pairNs_A() = (1,1)
            cons_A(x1,x2) = ((1,0),(1,0)) x1 + x2
            mark#_A(x1) = ((1,0),(0,0)) x1
            pair_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (0,1)
            s_A(x1) = ((1,0),(1,1)) x1 + (0,1)
            repItems_A(x1) = ((1,1),(1,1)) x1 + (2,1)
            a__repItems#_A(x1) = ((0,1),(0,0)) x1 + (1,0)
            mark_A(x1) = x1
            tail_A(x1) = x1 + (1,1)
            zip_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,1),(0,1)) x2 + (1,1)
            take_A(x1,x2) = ((1,1),(0,1)) x1 + ((1,1),(0,1)) x2 + (2,2)
            a__take#_A(x1,x2) = ((1,1),(0,0)) x2 + (1,0)
            oddNs_A() = (1,1)
            incr_A(x1) = x1
            a__oddNs_A() = (1,1)
            a__incr_A(x1) = x1
            a__take_A(x1,x2) = ((1,1),(0,1)) x1 + ((1,1),(0,1)) x2 + (2,2)
            |0|_A() = (0,1)
            nil_A() = (0,1)
            a__zip_A(x1,x2) = ((1,0),(1,0)) x1 + ((1,1),(0,1)) x2 + (1,1)
            a__tail_A(x1) = x1 + (1,1)
            a__repItems_A(x1) = ((1,1),(1,1)) x1 + (2,1)
            pairNs_A() = (1,1)
    
      precedence:
      
        mark > a__take > a__oddNs > oddNs > s > |0| = a__tail > tail > a__repItems > take > repItems > a__pairNs = pair = a__zip > zip > a__incr > nil > a__oddNs# = a__incr# = cons = mark# = a__repItems# = a__take# = incr = pairNs
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(pair) = []
        pi(s) = []
        pi(repItems) = [1]
        pi(a__repItems#) = []
        pi(mark) = []
        pi(tail) = [1]
        pi(zip) = [2]
        pi(take) = []
        pi(a__take#) = []
        pi(oddNs) = []
        pi(incr) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = [2]
        pi(a__tail) = []
        pi(a__repItems) = [1]
        pi(pairNs) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (4,3)
            a__incr#_A(x1) = (4,3)
            a__pairNs_A() = (0,4)
            cons_A(x1,x2) = (5,5)
            mark#_A(x1) = (4,3)
            pair_A(x1,x2) = (3,0)
            s_A(x1) = (3,6)
            repItems_A(x1) = ((0,1),(1,1)) x1 + (3,1)
            a__repItems#_A(x1) = (4,2)
            mark_A(x1) = (3,2)
            tail_A(x1) = (0,0)
            zip_A(x1,x2) = x2 + (0,1)
            take_A(x1,x2) = (0,1)
            a__take#_A(x1,x2) = (4,3)
            oddNs_A() = (0,2)
            incr_A(x1) = (1,1)
            a__oddNs_A() = (3,2)
            a__incr_A(x1) = (2,1)
            a__take_A(x1,x2) = (0,2)
            |0|_A() = (0,0)
            nil_A() = (0,0)
            a__zip_A(x1,x2) = x2 + (0,1)
            a__tail_A(x1) = (4,2)
            a__repItems_A(x1) = ((0,1),(0,1)) x1 + (1,0)
            pairNs_A() = (0,1)
    
      precedence:
      
        a__tail > zip = a__zip > repItems > a__oddNs# = a__incr# = cons = mark# = pair = s = mark = a__take# = |0| > a__repItems# > a__repItems > a__take = nil > take = oddNs = a__oddNs > a__pairNs > a__incr > pairNs > tail = incr
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(pair) = []
        pi(s) = []
        pi(repItems) = []
        pi(a__repItems#) = []
        pi(mark) = []
        pi(tail) = []
        pi(zip) = []
        pi(take) = []
        pi(a__take#) = []
        pi(oddNs) = []
        pi(incr) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = [2]
        pi(a__tail) = []
        pi(a__repItems) = []
        pi(pairNs) = []
    

The next rules are strictly ordered:

  p8, p9

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(cons(X1,X2)) -> mark#(X1)
p7: mark#(repItems(X)) -> mark#(X)
p8: mark#(tail(X)) -> mark#(X)
p9: mark#(zip(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> mark#(X1)
p11: mark#(take(X1,X2)) -> mark#(X2)
p12: mark#(take(X1,X2)) -> mark#(X1)
p13: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p14: a__take#(s(N),cons(X,XS)) -> mark#(X)
p15: mark#(oddNs()) -> a__oddNs#()
p16: mark#(incr(X)) -> mark#(X)
p17: mark#(incr(X)) -> a__incr#(mark(X))

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(incr(X)) -> a__incr#(mark(X))
p4: mark#(incr(X)) -> mark#(X)
p5: mark#(oddNs()) -> a__oddNs#()
p6: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p7: a__take#(s(N),cons(X,XS)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X1)
p9: mark#(take(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> mark#(X1)
p11: mark#(zip(X1,X2)) -> mark#(X2)
p12: mark#(tail(X)) -> mark#(X)
p13: mark#(repItems(X)) -> mark#(X)
p14: mark#(cons(X1,X2)) -> mark#(X1)
p15: mark#(s(X)) -> mark#(X)
p16: mark#(pair(X1,X2)) -> mark#(X1)
p17: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (3,3)
            a__incr#_A(x1) = ((1,0),(1,0)) x1 + (2,2)
            a__pairNs_A() = (1,1)
            cons_A(x1,x2) = ((1,0),(1,0)) x1 + ((0,1),(1,0)) x2
            mark#_A(x1) = ((1,0),(1,0)) x1 + (2,2)
            incr_A(x1) = x1
            mark_A(x1) = x1
            oddNs_A() = (1,1)
            take_A(x1,x2) = ((1,1),(0,1)) x1 + ((1,1),(1,1)) x2 + (3,2)
            a__take#_A(x1,x2) = ((1,1),(0,1)) x2 + (4,5)
            s_A(x1) = ((1,0),(1,1)) x1 + (0,1)
            zip_A(x1,x2) = x1 + x2
            tail_A(x1) = ((1,1),(1,1)) x1 + (1,1)
            repItems_A(x1) = ((1,1),(1,1)) x1 + (3,4)
            pair_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(1,0)) x2 + (0,1)
            a__oddNs_A() = (1,1)
            a__incr_A(x1) = x1
            a__take_A(x1,x2) = ((1,1),(0,1)) x1 + ((1,1),(1,1)) x2 + (3,2)
            |0|_A() = (0,1)
            nil_A() = (0,0)
            a__zip_A(x1,x2) = x1 + x2
            a__tail_A(x1) = ((1,1),(1,1)) x1 + (1,1)
            a__repItems_A(x1) = ((1,1),(1,1)) x1 + (3,4)
            pairNs_A() = (1,1)
    
      precedence:
      
        |0| > a__pairNs = mark = s = tail = pair = a__oddNs = a__incr = a__tail > a__oddNs# = a__incr# = cons = mark# = incr = take = a__take = nil = a__zip = a__repItems > repItems > zip > a__take# > oddNs = pairNs
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(incr) = []
        pi(mark) = [1]
        pi(oddNs) = []
        pi(take) = []
        pi(a__take#) = [2]
        pi(s) = [1]
        pi(zip) = [1]
        pi(tail) = []
        pi(repItems) = [1]
        pi(pair) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = [1]
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = [1]
        pi(a__tail) = [1]
        pi(a__repItems) = [1]
        pi(pairNs) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (8,4)
            a__incr#_A(x1) = (8,4)
            a__pairNs_A() = (9,5)
            cons_A(x1,x2) = (9,5)
            mark#_A(x1) = (8,4)
            incr_A(x1) = (1,2)
            mark_A(x1) = (3,4)
            oddNs_A() = (2,3)
            take_A(x1,x2) = (1,6)
            a__take#_A(x1,x2) = ((1,1),(0,1)) x2
            s_A(x1) = ((0,0),(1,0)) x1 + (2,1)
            zip_A(x1,x2) = (2,4)
            tail_A(x1) = (0,0)
            repItems_A(x1) = ((0,0),(0,1)) x1 + (10,0)
            pair_A(x1,x2) = (0,0)
            a__oddNs_A() = (2,3)
            a__incr_A(x1) = (2,3)
            a__take_A(x1,x2) = ((0,0),(0,1)) x1 + (10,6)
            |0|_A() = (3,0)
            nil_A() = (2,0)
            a__zip_A(x1,x2) = ((0,0),(0,1)) x1 + (3,0)
            a__tail_A(x1) = ((0,0),(0,1)) x1 + (3,0)
            a__repItems_A(x1) = x1 + (10,0)
            pairNs_A() = (0,1)
    
      precedence:
      
        a__pairNs > repItems = a__repItems > zip > a__oddNs# = a__incr# = mark# > mark = a__take# = a__take = |0| = nil = a__tail > take > a__oddNs = a__incr > a__zip > oddNs > cons = incr = s > tail > pairNs > pair
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = []
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(incr) = []
        pi(mark) = []
        pi(oddNs) = []
        pi(take) = []
        pi(a__take#) = [2]
        pi(s) = []
        pi(zip) = []
        pi(tail) = []
        pi(repItems) = []
        pi(pair) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = []
        pi(a__repItems) = [1]
        pi(pairNs) = []
    

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(incr(X)) -> a__incr#(mark(X))
p4: mark#(incr(X)) -> mark#(X)
p5: mark#(oddNs()) -> a__oddNs#()
p6: a__take#(s(N),cons(X,XS)) -> mark#(X)
p7: mark#(take(X1,X2)) -> mark#(X1)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(zip(X1,X2)) -> mark#(X1)
p10: mark#(zip(X1,X2)) -> mark#(X2)
p11: mark#(tail(X)) -> mark#(X)
p12: mark#(repItems(X)) -> mark#(X)
p13: mark#(cons(X1,X2)) -> mark#(X1)
p14: mark#(s(X)) -> mark#(X)
p15: mark#(pair(X1,X2)) -> mark#(X1)
p16: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: a__incr#(cons(X,XS)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(s(X)) -> mark#(X)
p6: mark#(cons(X1,X2)) -> mark#(X1)
p7: mark#(repItems(X)) -> mark#(X)
p8: mark#(tail(X)) -> mark#(X)
p9: mark#(zip(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> mark#(X1)
p11: mark#(take(X1,X2)) -> mark#(X2)
p12: mark#(take(X1,X2)) -> mark#(X1)
p13: mark#(oddNs()) -> a__oddNs#()
p14: mark#(incr(X)) -> mark#(X)
p15: mark#(incr(X)) -> a__incr#(mark(X))

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (1,1)
            a__incr#_A(x1) = x1
            a__pairNs_A() = (1,1)
            cons_A(x1,x2) = x1 + ((0,1),(1,0)) x2
            mark#_A(x1) = x1
            pair_A(x1,x2) = ((1,1),(0,1)) x1 + ((1,1),(0,1)) x2
            s_A(x1) = x1
            repItems_A(x1) = ((1,1),(1,1)) x1 + (2,1)
            tail_A(x1) = ((1,1),(1,1)) x1 + (1,1)
            zip_A(x1,x2) = ((1,1),(1,1)) x1 + ((1,1),(1,1)) x2 + (1,1)
            take_A(x1,x2) = ((1,1),(1,1)) x1 + x2 + (1,1)
            oddNs_A() = (1,1)
            incr_A(x1) = x1
            mark_A(x1) = x1
            a__oddNs_A() = (1,1)
            a__incr_A(x1) = x1
            a__take_A(x1,x2) = ((1,1),(1,1)) x1 + x2 + (1,1)
            |0|_A() = (0,0)
            nil_A() = (0,1)
            a__zip_A(x1,x2) = ((1,1),(1,1)) x1 + ((1,1),(1,1)) x2 + (1,1)
            a__tail_A(x1) = ((1,1),(1,1)) x1 + (1,1)
            a__repItems_A(x1) = ((1,1),(1,1)) x1 + (2,1)
            pairNs_A() = (1,1)
    
      precedence:
      
        oddNs = a__oddNs > incr = mark = a__incr = a__take = a__repItems > nil > a__zip > zip > a__oddNs# > a__pairNs > cons > tail = a__tail > pair > mark# = s > a__incr# > |0| > repItems = take > pairNs
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = [1]
        pi(a__pairNs) = []
        pi(cons) = [1]
        pi(mark#) = [1]
        pi(pair) = [1, 2]
        pi(s) = [1]
        pi(repItems) = [1]
        pi(tail) = [1]
        pi(zip) = [1, 2]
        pi(take) = [1, 2]
        pi(oddNs) = []
        pi(incr) = [1]
        pi(mark) = [1]
        pi(a__oddNs) = []
        pi(a__incr) = [1]
        pi(a__take) = [1]
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = [1, 2]
        pi(a__tail) = [1]
        pi(a__repItems) = []
        pi(pairNs) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: standard order
          interpretations:
            a__oddNs#_A() = (15,11)
            a__incr#_A(x1) = x1 + (1,0)
            a__pairNs_A() = (13,11)
            cons_A(x1,x2) = ((1,0),(0,0)) x1 + (10,11)
            mark#_A(x1) = ((1,0),(0,0)) x1 + (10,11)
            pair_A(x1,x2) = (11,12)
            s_A(x1) = ((1,0),(1,0)) x1 + (18,17)
            repItems_A(x1) = x1 + (1,0)
            tail_A(x1) = ((1,1),(0,0)) x1 + (9,0)
            zip_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (8,12)
            take_A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (11,17)
            oddNs_A() = (6,0)
            incr_A(x1) = (1,0)
            mark_A(x1) = ((0,1),(0,0)) x1 + (8,12)
            a__oddNs_A() = (8,11)
            a__incr_A(x1) = (2,11)
            a__take_A(x1,x2) = ((0,1),(0,0)) x1 + (12,12)
            |0|_A() = (2,1)
            nil_A() = (2,13)
            a__zip_A(x1,x2) = ((1,0),(0,0)) x1 + ((1,0),(0,0)) x2 + (9,13)
            a__tail_A(x1) = ((1,1),(0,1)) x1 + (9,0)
            a__repItems_A(x1) = (1,12)
            pairNs_A() = (1,6)
    
      precedence:
      
        mark = a__incr = a__tail > a__pairNs > pair = pairNs > tail > a__zip > |0| > nil > a__take > take > cons = s = zip > mark# > a__oddNs# > a__incr# > repItems = a__repItems > a__oddNs > oddNs = incr
      
      partial status:
    
        pi(a__oddNs#) = []
        pi(a__incr#) = [1]
        pi(a__pairNs) = []
        pi(cons) = []
        pi(mark#) = []
        pi(pair) = []
        pi(s) = []
        pi(repItems) = []
        pi(tail) = []
        pi(zip) = []
        pi(take) = []
        pi(oddNs) = []
        pi(incr) = []
        pi(mark) = []
        pi(a__oddNs) = []
        pi(a__incr) = []
        pi(a__take) = []
        pi(|0|) = []
        pi(nil) = []
        pi(a__zip) = []
        pi(a__tail) = [1]
        pi(a__repItems) = []
        pi(pairNs) = []
    

The next rules are strictly ordered:

  p2, p3, p4, p6, p12, p14, p15

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: a__oddNs#() -> a__incr#(a__pairNs())
p2: mark#(s(X)) -> mark#(X)
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(zip(X1,X2)) -> mark#(X2)
p6: mark#(zip(X1,X2)) -> mark#(X1)
p7: mark#(take(X1,X2)) -> mark#(X2)
p8: mark#(oddNs()) -> a__oddNs#()

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p2, p3, p4, p5, p6, p7}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: mark#(s(X)) -> mark#(X)
p2: mark#(take(X1,X2)) -> mark#(X2)
p3: mark#(zip(X1,X2)) -> mark#(X1)
p4: mark#(zip(X1,X2)) -> mark#(X2)
p5: mark#(tail(X)) -> mark#(X)
p6: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = ((1,0),(1,1)) x1 + (2,2)
            s_A(x1) = ((1,0),(1,1)) x1 + (3,3)
            take_A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (1,3)
            zip_A(x1,x2) = x1 + ((1,0),(0,0)) x2 + (3,3)
            tail_A(x1) = x1 + (3,1)
            repItems_A(x1) = ((1,0),(1,1)) x1 + (3,3)
    
      precedence:
      
        take = tail > s > mark# = zip = repItems
      
      partial status:
    
        pi(mark#) = [1]
        pi(s) = [1]
        pi(take) = [1]
        pi(zip) = [1]
        pi(tail) = [1]
        pi(repItems) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = (0,0)
            s_A(x1) = (1,0)
            take_A(x1,x2) = x1 + (1,0)
            zip_A(x1,x2) = ((1,0),(0,0)) x1 + (1,0)
            tail_A(x1) = ((1,0),(0,0)) x1 + (1,0)
            repItems_A(x1) = (1,0)
    
      precedence:
      
        s = zip > tail = repItems > mark# = take
      
      partial status:
    
        pi(mark#) = []
        pi(s) = []
        pi(take) = [1]
        pi(zip) = []
        pi(tail) = []
        pi(repItems) = []
    

The next rules are strictly ordered:

  p1, p3, p4, p5

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: mark#(take(X1,X2)) -> mark#(X2)
p2: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: mark#(take(X1,X2)) -> mark#(X2)
p2: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = x1 + (1,2)
            take_A(x1,x2) = x1 + x2 + (2,3)
            repItems_A(x1) = ((1,0),(1,1)) x1 + (2,1)
    
      precedence:
      
        mark# > take = repItems
      
      partial status:
    
        pi(mark#) = [1]
        pi(take) = []
        pi(repItems) = [1]
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = (0,0)
            take_A(x1,x2) = (1,1)
            repItems_A(x1) = (1,1)
    
      precedence:
      
        repItems > mark# = take
      
      partial status:
    
        pi(mark#) = []
        pi(take) = []
        pi(repItems) = []
    

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

Consider the dependency pair problem (P, R), where P consists of

p1: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

Consider the dependency pair problem (P, R), where P consists of

p1: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: a__pairNs() -> cons(|0|(),incr(oddNs()))
r2: a__oddNs() -> a__incr(a__pairNs())
r3: a__incr(cons(X,XS)) -> cons(s(mark(X)),incr(XS))
r4: a__take(|0|(),XS) -> nil()
r5: a__take(s(N),cons(X,XS)) -> cons(mark(X),take(N,XS))
r6: a__zip(nil(),XS) -> nil()
r7: a__zip(X,nil()) -> nil()
r8: a__zip(cons(X,XS),cons(Y,YS)) -> cons(pair(mark(X),mark(Y)),zip(XS,YS))
r9: a__tail(cons(X,XS)) -> mark(XS)
r10: a__repItems(nil()) -> nil()
r11: a__repItems(cons(X,XS)) -> cons(mark(X),cons(X,repItems(XS)))
r12: mark(pairNs()) -> a__pairNs()
r13: mark(incr(X)) -> a__incr(mark(X))
r14: mark(oddNs()) -> a__oddNs()
r15: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r16: mark(zip(X1,X2)) -> a__zip(mark(X1),mark(X2))
r17: mark(tail(X)) -> a__tail(mark(X))
r18: mark(repItems(X)) -> a__repItems(mark(X))
r19: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r20: mark(|0|()) -> |0|()
r21: mark(s(X)) -> s(mark(X))
r22: mark(nil()) -> nil()
r23: mark(pair(X1,X2)) -> pair(mark(X1),mark(X2))
r24: a__pairNs() -> pairNs()
r25: a__incr(X) -> incr(X)
r26: a__oddNs() -> oddNs()
r27: a__take(X1,X2) -> take(X1,X2)
r28: a__zip(X1,X2) -> zip(X1,X2)
r29: a__tail(X) -> tail(X)
r30: a__repItems(X) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = ((1,0),(1,1)) x1 + (2,2)
            repItems_A(x1) = ((1,0),(0,0)) x1 + (1,1)
    
      precedence:
      
        mark# = repItems
      
      partial status:
    
        pi(mark#) = []
        pi(repItems) = []
    
    2. weighted path order
    
      base order:
    
        matrix interpretations:
        
          carrier: N^2
          order: lexicographic order
          interpretations:
            mark#_A(x1) = ((1,0),(0,0)) x1
            repItems_A(x1) = (1,1)
    
      precedence:
      
        repItems > mark#
      
      partial status:
    
        pi(mark#) = []
        pi(repItems) = []
    

The next rules are strictly ordered:

  p1

We remove them from the problem.  Then no dependency pair remains.