YES

We show the termination of the TRS R:

  active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
  active(oddNs()) -> mark(incr(pairNs()))
  active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
  active(take(|0|(),XS)) -> mark(nil())
  active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
  active(zip(nil(),XS)) -> mark(nil())
  active(zip(X,nil())) -> mark(nil())
  active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
  active(tail(cons(X,XS))) -> mark(XS)
  active(repItems(nil())) -> mark(nil())
  active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
  mark(pairNs()) -> active(pairNs())
  mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
  mark(|0|()) -> active(|0|())
  mark(incr(X)) -> active(incr(mark(X)))
  mark(oddNs()) -> active(oddNs())
  mark(s(X)) -> active(s(mark(X)))
  mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
  mark(nil()) -> active(nil())
  mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
  mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
  mark(tail(X)) -> active(tail(mark(X)))
  mark(repItems(X)) -> active(repItems(mark(X)))
  cons(mark(X1),X2) -> cons(X1,X2)
  cons(X1,mark(X2)) -> cons(X1,X2)
  cons(active(X1),X2) -> cons(X1,X2)
  cons(X1,active(X2)) -> cons(X1,X2)
  incr(mark(X)) -> incr(X)
  incr(active(X)) -> incr(X)
  s(mark(X)) -> s(X)
  s(active(X)) -> s(X)
  take(mark(X1),X2) -> take(X1,X2)
  take(X1,mark(X2)) -> take(X1,X2)
  take(active(X1),X2) -> take(X1,X2)
  take(X1,active(X2)) -> take(X1,X2)
  zip(mark(X1),X2) -> zip(X1,X2)
  zip(X1,mark(X2)) -> zip(X1,X2)
  zip(active(X1),X2) -> zip(X1,X2)
  zip(X1,active(X2)) -> zip(X1,X2)
  pair(mark(X1),X2) -> pair(X1,X2)
  pair(X1,mark(X2)) -> pair(X1,X2)
  pair(active(X1),X2) -> pair(X1,X2)
  pair(X1,active(X2)) -> pair(X1,X2)
  tail(mark(X)) -> tail(X)
  tail(active(X)) -> tail(X)
  repItems(mark(X)) -> repItems(X)
  repItems(active(X)) -> repItems(X)

-- SCC decomposition.

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

p1: active#(pairNs()) -> mark#(cons(|0|(),incr(oddNs())))
p2: active#(pairNs()) -> cons#(|0|(),incr(oddNs()))
p3: active#(pairNs()) -> incr#(oddNs())
p4: active#(oddNs()) -> mark#(incr(pairNs()))
p5: active#(oddNs()) -> incr#(pairNs())
p6: active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
p7: active#(incr(cons(X,XS))) -> cons#(s(X),incr(XS))
p8: active#(incr(cons(X,XS))) -> s#(X)
p9: active#(incr(cons(X,XS))) -> incr#(XS)
p10: active#(take(|0|(),XS)) -> mark#(nil())
p11: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p12: active#(take(s(N),cons(X,XS))) -> cons#(X,take(N,XS))
p13: active#(take(s(N),cons(X,XS))) -> take#(N,XS)
p14: active#(zip(nil(),XS)) -> mark#(nil())
p15: active#(zip(X,nil())) -> mark#(nil())
p16: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p17: active#(zip(cons(X,XS),cons(Y,YS))) -> cons#(pair(X,Y),zip(XS,YS))
p18: active#(zip(cons(X,XS),cons(Y,YS))) -> pair#(X,Y)
p19: active#(zip(cons(X,XS),cons(Y,YS))) -> zip#(XS,YS)
p20: active#(tail(cons(X,XS))) -> mark#(XS)
p21: active#(repItems(nil())) -> mark#(nil())
p22: active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
p23: active#(repItems(cons(X,XS))) -> cons#(X,cons(X,repItems(XS)))
p24: active#(repItems(cons(X,XS))) -> cons#(X,repItems(XS))
p25: active#(repItems(cons(X,XS))) -> repItems#(XS)
p26: mark#(pairNs()) -> active#(pairNs())
p27: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p28: mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
p29: mark#(cons(X1,X2)) -> mark#(X1)
p30: mark#(|0|()) -> active#(|0|())
p31: mark#(incr(X)) -> active#(incr(mark(X)))
p32: mark#(incr(X)) -> incr#(mark(X))
p33: mark#(incr(X)) -> mark#(X)
p34: mark#(oddNs()) -> active#(oddNs())
p35: mark#(s(X)) -> active#(s(mark(X)))
p36: mark#(s(X)) -> s#(mark(X))
p37: mark#(s(X)) -> mark#(X)
p38: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p39: mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
p40: mark#(take(X1,X2)) -> mark#(X1)
p41: mark#(take(X1,X2)) -> mark#(X2)
p42: mark#(nil()) -> active#(nil())
p43: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p44: mark#(zip(X1,X2)) -> zip#(mark(X1),mark(X2))
p45: mark#(zip(X1,X2)) -> mark#(X1)
p46: mark#(zip(X1,X2)) -> mark#(X2)
p47: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p48: mark#(pair(X1,X2)) -> pair#(mark(X1),mark(X2))
p49: mark#(pair(X1,X2)) -> mark#(X1)
p50: mark#(pair(X1,X2)) -> mark#(X2)
p51: mark#(tail(X)) -> active#(tail(mark(X)))
p52: mark#(tail(X)) -> tail#(mark(X))
p53: mark#(tail(X)) -> mark#(X)
p54: mark#(repItems(X)) -> active#(repItems(mark(X)))
p55: mark#(repItems(X)) -> repItems#(mark(X))
p56: mark#(repItems(X)) -> mark#(X)
p57: cons#(mark(X1),X2) -> cons#(X1,X2)
p58: cons#(X1,mark(X2)) -> cons#(X1,X2)
p59: cons#(active(X1),X2) -> cons#(X1,X2)
p60: cons#(X1,active(X2)) -> cons#(X1,X2)
p61: incr#(mark(X)) -> incr#(X)
p62: incr#(active(X)) -> incr#(X)
p63: s#(mark(X)) -> s#(X)
p64: s#(active(X)) -> s#(X)
p65: take#(mark(X1),X2) -> take#(X1,X2)
p66: take#(X1,mark(X2)) -> take#(X1,X2)
p67: take#(active(X1),X2) -> take#(X1,X2)
p68: take#(X1,active(X2)) -> take#(X1,X2)
p69: zip#(mark(X1),X2) -> zip#(X1,X2)
p70: zip#(X1,mark(X2)) -> zip#(X1,X2)
p71: zip#(active(X1),X2) -> zip#(X1,X2)
p72: zip#(X1,active(X2)) -> zip#(X1,X2)
p73: pair#(mark(X1),X2) -> pair#(X1,X2)
p74: pair#(X1,mark(X2)) -> pair#(X1,X2)
p75: pair#(active(X1),X2) -> pair#(X1,X2)
p76: pair#(X1,active(X2)) -> pair#(X1,X2)
p77: tail#(mark(X)) -> tail#(X)
p78: tail#(active(X)) -> tail#(X)
p79: repItems#(mark(X)) -> repItems#(X)
p80: repItems#(active(X)) -> repItems#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p4, p6, p11, p16, p20, p22, p26, p27, p29, p31, p33, p34, p35, p37, p38, p40, p41, p43, p45, p46, p47, p49, p50, p51, p53, p54, p56}
  {p57, p58, p59, p60}
  {p63, p64}
  {p61, p62}
  {p65, p66, p67, p68}
  {p73, p74, p75, p76}
  {p69, p70, p71, p72}
  {p79, p80}
  {p77, p78}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        active#_A(x1) = max{37, x1 + 35}
        pairNs_A = 83
        mark#_A(x1) = max{48, x1 + 35}
        cons_A(x1,x2) = max{x1 + 53, x2 - 80}
        |0|_A = 29
        incr_A(x1) = max{107, x1 + 39}
        oddNs_A = 123
        repItems_A(x1) = x1 + 75
        mark_A(x1) = x1
        tail_A(x1) = x1 + 114
        pair_A(x1,x2) = max{x1 + 36, x2 + 36}
        zip_A(x1,x2) = max{260, x1 + 130, x2 + 127}
        take_A(x1,x2) = max{x1 + 166, x2 + 165}
        s_A(x1) = max{54, x1 + 38}
        active_A(x1) = max{28, x1}
        nil_A = 126
  
    precedence:
    
      tail > oddNs > pairNs = |0| = incr > active# = mark# = cons = repItems = mark = pair = zip = take = s = active = nil
    
    partial status:
  
      pi(active#) = [1]
      pi(pairNs) = []
      pi(mark#) = [1]
      pi(cons) = []
      pi(|0|) = []
      pi(incr) = []
      pi(oddNs) = []
      pi(repItems) = []
      pi(mark) = []
      pi(tail) = []
      pi(pair) = []
      pi(zip) = []
      pi(take) = []
      pi(s) = []
      pi(active) = []
      pi(nil) = []

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#(cons(X1,X2)) -> mark#(X1)
p2: mark#(repItems(X)) -> mark#(X)
p3: mark#(repItems(X)) -> active#(repItems(mark(X)))
p4: active#(repItems(cons(X,XS))) -> mark#(cons(X,cons(X,repItems(XS))))
p5: mark#(tail(X)) -> mark#(X)
p6: mark#(tail(X)) -> active#(tail(mark(X)))
p7: active#(tail(cons(X,XS))) -> mark#(XS)
p8: mark#(pair(X1,X2)) -> mark#(X2)
p9: mark#(pair(X1,X2)) -> mark#(X1)
p10: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p11: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p12: mark#(zip(X1,X2)) -> mark#(X2)
p13: mark#(zip(X1,X2)) -> mark#(X1)
p14: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p15: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p16: mark#(take(X1,X2)) -> mark#(X2)
p17: mark#(take(X1,X2)) -> mark#(X1)
p18: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p19: active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
p20: mark#(s(X)) -> mark#(X)
p21: mark#(s(X)) -> active#(s(mark(X)))
p22: active#(oddNs()) -> mark#(incr(pairNs()))
p23: mark#(incr(X)) -> mark#(X)
p24: mark#(oddNs()) -> active#(oddNs())
p25: mark#(incr(X)) -> active#(incr(mark(X)))
p26: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p27: mark#(pairNs()) -> active#(pairNs())

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, p23, p24, p25, p26}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 80
        cons_A(x1,x2) = max{21, x1 + 13, x2 - 89}
        active#_A(x1) = max{101, x1 + 80}
        mark_A(x1) = max{3, x1}
        oddNs_A = 94
        incr_A(x1) = max{48, x1 + 44}
        pairNs_A = 49
        s_A(x1) = max{21, x1 + 18}
        take_A(x1,x2) = max{21, x1 + 18, x2 + 14}
        zip_A(x1,x2) = max{21, x1 + 18, x2 + 14}
        pair_A(x1,x2) = max{21, x1, x2 + 5}
        tail_A(x1) = max{92, x1 + 89}
        repItems_A(x1) = max{100, x1 + 79}
        active_A(x1) = max{2, x1}
        |0|_A = 36
        nil_A = 1
  
    precedence:
    
      take = pair > mark# = active# = incr > cons = oddNs = pairNs = tail = |0| > nil > mark = s = zip = repItems = active
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = []
      pi(active#) = []
      pi(mark) = []
      pi(oddNs) = []
      pi(incr) = []
      pi(pairNs) = []
      pi(s) = []
      pi(take) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(|0|) = []
      pi(nil) = []

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{29, x1 - 4}
        cons_A(x1,x2) = max{x1 + 25, x2 - 16}
        repItems_A(x1) = x1 + 62
        active#_A(x1) = max{4, x1 - 4}
        mark_A(x1) = x1
        tail_A(x1) = max{53, x1 + 50}
        pair_A(x1,x2) = max{x1 + 55, x2 + 102}
        zip_A(x1,x2) = max{x1 + 55, x2 + 105}
        take_A(x1,x2) = max{x1 + 55, x2 + 55}
        s_A(x1) = x1 + 7
        incr_A(x1) = max{33, x1 + 8}
        active_A(x1) = max{6, x1}
        pairNs_A = 31
        |0|_A = 6
        oddNs_A = 39
        nil_A = 6
  
    precedence:
    
      mark = active = pairNs > repItems = |0| = oddNs > cons > mark# = active# = nil > tail = pair = zip = take = s > incr
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = []
      pi(repItems) = []
      pi(active#) = []
      pi(mark) = []
      pi(tail) = []
      pi(pair) = [2]
      pi(zip) = [1]
      pi(take) = [1]
      pi(s) = []
      pi(incr) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, p23}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 86
        cons_A(x1,x2) = max{x1 + 14, x2 - 74}
        active#_A(x1) = x1 + 86
        mark_A(x1) = x1
        incr_A(x1) = x1 + 36
        s_A(x1) = max{14, x1}
        take_A(x1,x2) = max{x1 + 9, x2 + 85}
        zip_A(x1,x2) = max{x1 + 87, x2 + 87}
        pair_A(x1,x2) = max{x1 + 14, x2}
        tail_A(x1) = max{101, x1 + 87}
        repItems_A(x1) = max{163, x1 + 9}
        active_A(x1) = max{14, x1}
        pairNs_A = 29
        |0|_A = 15
        oddNs_A = 66
        nil_A = 16
  
    precedence:
    
      mark = s = pair = tail = active > |0| > zip = repItems = pairNs > mark# = cons = active# = incr = take = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = [1]
      pi(active#) = []
      pi(mark) = []
      pi(incr) = []
      pi(s) = []
      pi(take) = [2]
      pi(zip) = [1]
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

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: mark#(cons(X1,X2)) -> mark#(X1)
p2: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p3: active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
p4: mark#(incr(X)) -> active#(incr(mark(X)))
p5: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p6: mark#(s(X)) -> active#(s(mark(X)))
p7: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p8: mark#(s(X)) -> mark#(X)
p9: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p10: active#(tail(cons(X,XS))) -> mark#(XS)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> mark#(X2)
p13: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p14: mark#(zip(X1,X2)) -> mark#(X1)
p15: mark#(zip(X1,X2)) -> mark#(X2)
p16: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p17: mark#(pair(X1,X2)) -> mark#(X1)
p18: mark#(pair(X1,X2)) -> mark#(X2)
p19: mark#(tail(X)) -> active#(tail(mark(X)))
p20: mark#(tail(X)) -> mark#(X)
p21: mark#(repItems(X)) -> active#(repItems(mark(X)))
p22: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: mark#(cons(X1,X2)) -> mark#(X1)
p2: mark#(repItems(X)) -> mark#(X)
p3: mark#(repItems(X)) -> active#(repItems(mark(X)))
p4: active#(tail(cons(X,XS))) -> mark#(XS)
p5: mark#(tail(X)) -> mark#(X)
p6: mark#(tail(X)) -> active#(tail(mark(X)))
p7: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p8: mark#(pair(X1,X2)) -> mark#(X2)
p9: mark#(pair(X1,X2)) -> mark#(X1)
p10: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p11: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p12: mark#(zip(X1,X2)) -> mark#(X2)
p13: mark#(zip(X1,X2)) -> mark#(X1)
p14: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p15: active#(incr(cons(X,XS))) -> mark#(cons(s(X),incr(XS)))
p16: mark#(take(X1,X2)) -> mark#(X2)
p17: mark#(take(X1,X2)) -> mark#(X1)
p18: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p19: mark#(s(X)) -> mark#(X)
p20: mark#(s(X)) -> active#(s(mark(X)))
p21: mark#(incr(X)) -> active#(incr(mark(X)))
p22: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 32
        cons_A(x1,x2) = max{2, x1, x2 - 13}
        repItems_A(x1) = max{1, x1}
        active#_A(x1) = x1 + 32
        mark_A(x1) = x1
        tail_A(x1) = x1 + 18
        zip_A(x1,x2) = max{x1 + 19, x2 + 18}
        pair_A(x1,x2) = max{x1, x2}
        take_A(x1,x2) = max{x1 + 81, x2 + 48}
        s_A(x1) = x1 + 6
        incr_A(x1) = max{16, x1 + 6}
        active_A(x1) = x1
        pairNs_A = 10
        |0|_A = 1
        oddNs_A = 17
        nil_A = 2
  
    precedence:
    
      mark# = repItems = active# = tail = incr = pairNs = |0| = oddNs > zip > cons = pair = take > mark = s = active = nil
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = []
      pi(repItems) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(tail) = []
      pi(zip) = []
      pi(pair) = []
      pi(take) = []
      pi(s) = []
      pi(incr) = []
      pi(active) = [1]
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{2, x1}
        cons_A(x1,x2) = max{42, x1 + 3, x2 - 33}
        active#_A(x1) = max{13, x1}
        mark_A(x1) = x1
        incr_A(x1) = x1 + 16
        s_A(x1) = x1 + 15
        take_A(x1,x2) = max{x1 + 76, x2 + 76}
        zip_A(x1,x2) = max{x1 + 38, x2 + 43}
        pair_A(x1,x2) = max{x1 + 37, x2 + 43}
        tail_A(x1) = x1 + 33
        repItems_A(x1) = x1 + 109
        active_A(x1) = max{11, x1}
        pairNs_A = 42
        |0|_A = 12
        oddNs_A = 58
        nil_A = 37
  
    precedence:
    
      pairNs > s > repItems > take = zip = pair = tail = nil > oddNs > incr = |0| > cons > mark# > active# = mark = active
    
    partial status:
  
      pi(mark#) = [1]
      pi(cons) = []
      pi(active#) = [1]
      pi(mark) = []
      pi(incr) = []
      pi(s) = []
      pi(take) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p3

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 35
        cons_A(x1,x2) = max{x1 + 3, x2 - 15}
        repItems_A(x1) = max{39, x1 + 36}
        active#_A(x1) = x1 + 35
        mark_A(x1) = x1
        zip_A(x1,x2) = max{x1 + 68, x2 + 52}
        pair_A(x1,x2) = max{x1 + 68, x2 + 1}
        tail_A(x1) = x1 + 16
        take_A(x1,x2) = max{35, x1 + 12, x2 + 32}
        s_A(x1) = x1 + 7
        incr_A(x1) = x1 + 7
        active_A(x1) = max{3, x1}
        pairNs_A = 8
        |0|_A = 5
        oddNs_A = 16
        nil_A = 4
  
    precedence:
    
      mark# = active# = pair = tail = take = incr = |0| > pairNs > cons = repItems = mark = zip = s = active = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = []
      pi(repItems) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(take) = []
      pi(s) = []
      pi(incr) = []
      pi(active) = [1]
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p15

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: mark#(cons(X1,X2)) -> mark#(X1)
p2: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p3: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p4: mark#(incr(X)) -> active#(incr(mark(X)))
p5: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p6: mark#(s(X)) -> active#(s(mark(X)))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p9: mark#(take(X1,X2)) -> mark#(X2)
p10: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p11: mark#(zip(X1,X2)) -> mark#(X1)
p12: mark#(zip(X1,X2)) -> mark#(X2)
p13: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p14: mark#(pair(X1,X2)) -> mark#(X1)
p15: mark#(pair(X1,X2)) -> mark#(X2)
p16: mark#(tail(X)) -> active#(tail(mark(X)))
p17: mark#(tail(X)) -> mark#(X)
p18: mark#(repItems(X)) -> active#(repItems(mark(X)))
p19: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{29, x1}
        cons_A(x1,x2) = max{2, x1, x2 - 5}
        active#_A(x1) = max{1, x1}
        mark_A(x1) = max{9, x1}
        take_A(x1,x2) = max{53, x1 + 44, x2 + 35}
        s_A(x1) = max{9, x1}
        incr_A(x1) = max{8, x1}
        zip_A(x1,x2) = max{54, x1 + 45, x2 + 35}
        pair_A(x1,x2) = max{28, x1 + 19, x2 + 9}
        tail_A(x1) = max{30, x1 + 20}
        repItems_A(x1) = max{9, x1}
        active_A(x1) = max{9, x1}
        pairNs_A = 1
        |0|_A = 0
        oddNs_A = 7
        nil_A = 9
  
    precedence:
    
      mark# = active# = take = zip = tail = oddNs > cons = mark = s = incr = pair = repItems = active = nil > pairNs = |0|
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = []
      pi(active#) = []
      pi(mark) = []
      pi(take) = []
      pi(s) = []
      pi(incr) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p9

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{2, x1}
        cons_A(x1,x2) = max{x1 + 17, x2 - 17}
        repItems_A(x1) = x1 + 54
        active#_A(x1) = max{17, x1}
        mark_A(x1) = x1
        zip_A(x1,x2) = max{x1 + 53, x2 + 20}
        pair_A(x1,x2) = max{x1 + 19, x2 + 20}
        tail_A(x1) = x1 + 17
        take_A(x1,x2) = max{x1 + 41, x2 + 41}
        s_A(x1) = max{24, x1 + 1}
        incr_A(x1) = max{41, x1 + 8}
        active_A(x1) = max{7, x1}
        pairNs_A = 32
        |0|_A = 7
        oddNs_A = 41
        nil_A = 22
  
    precedence:
    
      zip > pairNs > take > mark# > pair > cons = oddNs > active# > tail = s > repItems > mark = active = |0| = nil > incr
    
    partial status:
  
      pi(mark#) = [1]
      pi(cons) = []
      pi(repItems) = []
      pi(active#) = [1]
      pi(mark) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(take) = []
      pi(s) = []
      pi(incr) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p18

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: mark#(cons(X1,X2)) -> mark#(X1)
p2: mark#(incr(X)) -> active#(incr(mark(X)))
p3: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p4: mark#(s(X)) -> active#(s(mark(X)))
p5: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p8: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p9: mark#(zip(X1,X2)) -> mark#(X1)
p10: mark#(zip(X1,X2)) -> mark#(X2)
p11: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p12: mark#(pair(X1,X2)) -> mark#(X1)
p13: mark#(pair(X1,X2)) -> mark#(X2)
p14: mark#(tail(X)) -> active#(tail(mark(X)))
p15: mark#(tail(X)) -> mark#(X)
p16: mark#(repItems(X)) -> active#(repItems(mark(X)))
p17: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{1, x1 - 3}
        cons_A(x1,x2) = max{14, x1 + 7, x2 - 30}
        incr_A(x1) = max{45, x1 + 14}
        active#_A(x1) = max{2, x1 - 3}
        mark_A(x1) = x1
        take_A(x1,x2) = max{x1 + 50, x2 + 48}
        s_A(x1) = x1 + 14
        zip_A(x1,x2) = max{x1 + 56, x2 + 56}
        pair_A(x1,x2) = max{x1 + 16, x2 + 17}
        tail_A(x1) = x1 + 31
        repItems_A(x1) = x1 + 106
        active_A(x1) = max{14, x1}
        pairNs_A = 31
        |0|_A = 15
        oddNs_A = 46
        nil_A = 47
  
    precedence:
    
      incr > mark# = active# > take = s = zip > cons = mark > pair = tail = repItems = active = pairNs = |0| = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(cons) = [1]
      pi(incr) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(take) = []
      pi(s) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = [1]
      pi(repItems) = []
      pi(active) = [1]
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

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#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(s(X)) -> active#(s(mark(X)))
p4: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p7: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p8: mark#(zip(X1,X2)) -> mark#(X1)
p9: mark#(zip(X1,X2)) -> mark#(X2)
p10: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p11: mark#(pair(X1,X2)) -> mark#(X1)
p12: mark#(pair(X1,X2)) -> mark#(X2)
p13: mark#(tail(X)) -> active#(tail(mark(X)))
p14: mark#(tail(X)) -> mark#(X)
p15: mark#(repItems(X)) -> active#(repItems(mark(X)))
p16: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{0, x1 - 17}
        incr_A(x1) = max{2, x1}
        active#_A(x1) = max{0, x1 - 17}
        mark_A(x1) = x1
        zip_A(x1,x2) = max{33, x1 + 25, x2 + 25}
        cons_A(x1,x2) = max{3, x2}
        pair_A(x1,x2) = max{17, x1, x2}
        repItems_A(x1) = x1 + 23
        take_A(x1,x2) = max{x1 + 32, x2 + 32}
        s_A(x1) = x1 + 5
        tail_A(x1) = x1 + 36
        active_A(x1) = max{1, x1}
        pairNs_A = 8
        |0|_A = 2
        oddNs_A = 8
        nil_A = 22
  
    precedence:
    
      mark# = incr = active# = mark = zip = pair = repItems = active > cons = take = s = tail = pairNs = |0| = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(incr) = []
      pi(active#) = []
      pi(mark) = []
      pi(zip) = []
      pi(cons) = []
      pi(pair) = []
      pi(repItems) = []
      pi(take) = [1]
      pi(s) = [1]
      pi(tail) = [1]
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p11

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{15, x1}
        incr_A(x1) = max{24, x1 - 11}
        active#_A(x1) = max{1, x1}
        mark_A(x1) = x1
        take_A(x1,x2) = max{x1 + 9, x2 + 26}
        s_A(x1) = max{25, x1 + 5}
        cons_A(x1,x2) = max{18, x2 - 6}
        zip_A(x1,x2) = max{x1 + 25, x2 + 25}
        pair_A(x1,x2) = max{x1 + 24, x2 + 24}
        tail_A(x1) = max{15, x1 + 7}
        repItems_A(x1) = x1 + 63
        active_A(x1) = max{8, x1}
        pairNs_A = 18
        |0|_A = 9
        oddNs_A = 35
        nil_A = 16
  
    precedence:
    
      incr = mark = tail = active = |0| = oddNs = nil > repItems > s = zip = pair > active# = take > mark# = cons = pairNs
    
    partial status:
  
      pi(mark#) = [1]
      pi(incr) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(take) = []
      pi(s) = []
      pi(cons) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = [1]
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p14

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(s(X)) -> active#(s(mark(X)))
p4: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p7: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p8: mark#(zip(X1,X2)) -> mark#(X1)
p9: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p10: mark#(pair(X1,X2)) -> mark#(X1)
p11: mark#(pair(X1,X2)) -> mark#(X2)
p12: mark#(tail(X)) -> active#(tail(mark(X)))
p13: mark#(tail(X)) -> mark#(X)
p14: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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}


-- Reduction pair.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(zip(cons(X,XS),cons(Y,YS))) -> mark#(cons(pair(X,Y),zip(XS,YS)))
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(tail(X)) -> active#(tail(mark(X)))
p6: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p7: mark#(pair(X1,X2)) -> mark#(X2)
p8: mark#(pair(X1,X2)) -> mark#(X1)
p9: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p10: mark#(zip(X1,X2)) -> mark#(X1)
p11: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p12: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p13: mark#(s(X)) -> mark#(X)
p14: mark#(s(X)) -> active#(s(mark(X)))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{10, x1 + 5}
        incr_A(x1) = x1 + 15
        active#_A(x1) = x1 + 5
        mark_A(x1) = x1
        zip_A(x1,x2) = max{x1 + 91, x2 + 91}
        cons_A(x1,x2) = max{4, x1 - 43, x2 - 32}
        pair_A(x1,x2) = max{x1 + 45, x2 + 46}
        repItems_A(x1) = x1
        tail_A(x1) = x1 + 44
        take_A(x1,x2) = x2 + 48
        s_A(x1) = x1 + 10
        active_A(x1) = x1
        pairNs_A = 5
        |0|_A = 44
        oddNs_A = 21
        nil_A = 4
  
    precedence:
    
      incr = mark = zip = repItems = s = active > oddNs > mark# = active# = cons = pair = tail = take = pairNs = |0| = nil
    
    partial status:
  
      pi(mark#) = [1]
      pi(incr) = []
      pi(active#) = [1]
      pi(mark) = []
      pi(zip) = []
      pi(cons) = []
      pi(pair) = []
      pi(repItems) = []
      pi(tail) = []
      pi(take) = []
      pi(s) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{68, x1 + 5}
        incr_A(x1) = max{2, x1}
        active#_A(x1) = max{68, x1 + 5}
        mark_A(x1) = max{3, x1}
        take_A(x1,x2) = max{35, x1 + 32, x2}
        s_A(x1) = x1
        cons_A(x1,x2) = max{23, x1 - 31, x2 - 18}
        zip_A(x1,x2) = max{123, x1 + 99, x2 + 55}
        pair_A(x1,x2) = max{67, x1 + 64, x2 + 55}
        tail_A(x1) = max{67, x1 + 64}
        repItems_A(x1) = max{4, x1}
        active_A(x1) = max{1, x1}
        pairNs_A = 24
        |0|_A = 55
        oddNs_A = 41
        nil_A = 36
  
    precedence:
    
      zip > mark# = incr = active# = mark = take = s = cons = pair = tail = repItems = active = pairNs = |0| = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(incr) = []
      pi(active#) = []
      pi(mark) = []
      pi(take) = []
      pi(s) = []
      pi(cons) = []
      pi(zip) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(s(X)) -> active#(s(mark(X)))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p6: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p7: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p8: mark#(pair(X1,X2)) -> mark#(X1)
p9: mark#(pair(X1,X2)) -> mark#(X2)
p10: mark#(tail(X)) -> active#(tail(mark(X)))
p11: mark#(tail(X)) -> mark#(X)
p12: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12}


-- Reduction pair.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(tail(X)) -> active#(tail(mark(X)))
p6: mark#(pair(X1,X2)) -> mark#(X2)
p7: mark#(pair(X1,X2)) -> mark#(X1)
p8: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p9: mark#(zip(X1,X2)) -> active#(zip(mark(X1),mark(X2)))
p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(s(X)) -> active#(s(mark(X)))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{82, x1 - 31}
        incr_A(x1) = 45
        active#_A(x1) = max{3, x1 - 31}
        mark_A(x1) = max{43, x1}
        take_A(x1,x2) = max{113, x1 + 41}
        s_A(x1) = max{42, x1}
        cons_A(x1,x2) = max{2, x2 - 62}
        repItems_A(x1) = max{83, x1 + 20}
        tail_A(x1) = max{158, x1 + 114}
        pair_A(x1,x2) = max{158, x1 + 115, x2 + 40}
        zip_A(x1,x2) = 102
        active_A(x1) = max{42, x1}
        pairNs_A = 44
        |0|_A = 45
        oddNs_A = 46
        nil_A = 82
  
    precedence:
    
      incr > mark# = active# > mark = take = s = cons = repItems = tail = pair = zip = active = pairNs = |0| = oddNs = nil
    
    partial status:
  
      pi(mark#) = []
      pi(incr) = []
      pi(active#) = []
      pi(mark) = [1]
      pi(take) = []
      pi(s) = []
      pi(cons) = []
      pi(repItems) = []
      pi(tail) = []
      pi(pair) = []
      pi(zip) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []

The next rules are strictly ordered:

  p9

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(tail(X)) -> active#(tail(mark(X)))
p6: mark#(pair(X1,X2)) -> mark#(X2)
p7: mark#(pair(X1,X2)) -> mark#(X1)
p8: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p9: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p10: mark#(s(X)) -> mark#(X)
p11: mark#(s(X)) -> active#(s(mark(X)))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11}


-- Reduction pair.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(s(X)) -> active#(s(mark(X)))
p4: mark#(s(X)) -> mark#(X)
p5: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p6: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p7: mark#(pair(X1,X2)) -> mark#(X1)
p8: mark#(pair(X1,X2)) -> mark#(X2)
p9: mark#(tail(X)) -> active#(tail(mark(X)))
p10: mark#(tail(X)) -> mark#(X)
p11: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{39, x1}
        incr_A(x1) = x1 + 7
        active#_A(x1) = max{1, x1}
        mark_A(x1) = x1
        take_A(x1,x2) = max{x1 + 57, x2 + 56}
        s_A(x1) = x1 + 4
        cons_A(x1,x2) = max{2, x1, x2 - 16}
        pair_A(x1,x2) = max{x1 + 38, x2 + 18}
        tail_A(x1) = x1 + 41
        repItems_A(x1) = x1 + 31
        active_A(x1) = max{2, x1}
        pairNs_A = 5
        |0|_A = 4
        oddNs_A = 13
        nil_A = 3
        zip_A(x1,x2) = max{x1 + 38, x2 + 19}
  
    precedence:
    
      incr = repItems > mark# = active# = mark = take = s = cons = pair = tail = active = pairNs = |0| = oddNs = nil = zip
    
    partial status:
  
      pi(mark#) = [1]
      pi(incr) = []
      pi(active#) = [1]
      pi(mark) = [1]
      pi(take) = []
      pi(s) = []
      pi(cons) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = [1]
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []
      pi(zip) = []

The next rules are strictly ordered:

  p4

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(s(X)) -> active#(s(mark(X)))
p4: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p5: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p6: mark#(pair(X1,X2)) -> mark#(X1)
p7: mark#(pair(X1,X2)) -> mark#(X2)
p8: mark#(tail(X)) -> active#(tail(mark(X)))
p9: mark#(tail(X)) -> mark#(X)
p10: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10}


-- Reduction pair.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(tail(X)) -> active#(tail(mark(X)))
p6: mark#(pair(X1,X2)) -> mark#(X2)
p7: mark#(pair(X1,X2)) -> mark#(X1)
p8: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p9: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p10: mark#(s(X)) -> active#(s(mark(X)))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{34, x1 + 14}
        incr_A(x1) = max{21, x1 + 8}
        active#_A(x1) = max{21, x1 - 3}
        mark_A(x1) = x1
        take_A(x1,x2) = max{37, x1 + 8}
        s_A(x1) = x1 + 29
        cons_A(x1,x2) = max{20, x2 - 19}
        repItems_A(x1) = x1 + 83
        tail_A(x1) = max{40, x1 + 38}
        pair_A(x1,x2) = max{x1 + 129, x2 + 129}
        active_A(x1) = max{2, x1}
        pairNs_A = 20
        |0|_A = 116
        oddNs_A = 29
        nil_A = 124
        zip_A(x1,x2) = max{124, x1 + 83, x2 + 84}
  
    precedence:
    
      incr = mark = active > zip > take = s = cons = nil > repItems > active# = pair > mark# = tail = pairNs = |0| = oddNs
    
    partial status:
  
      pi(mark#) = [1]
      pi(incr) = []
      pi(active#) = []
      pi(mark) = []
      pi(take) = []
      pi(s) = [1]
      pi(cons) = []
      pi(repItems) = [1]
      pi(tail) = []
      pi(pair) = [1]
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []
      pi(zip) = []

The next rules are strictly ordered:

  p10

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(repItems(X)) -> mark#(X)
p4: mark#(tail(X)) -> mark#(X)
p5: mark#(tail(X)) -> active#(tail(mark(X)))
p6: mark#(pair(X1,X2)) -> mark#(X2)
p7: mark#(pair(X1,X2)) -> mark#(X1)
p8: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p9: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9}


-- Reduction pair.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: active#(take(s(N),cons(X,XS))) -> mark#(cons(X,take(N,XS)))
p3: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p4: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p5: mark#(pair(X1,X2)) -> mark#(X1)
p6: mark#(pair(X1,X2)) -> mark#(X2)
p7: mark#(tail(X)) -> active#(tail(mark(X)))
p8: mark#(tail(X)) -> mark#(X)
p9: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 25
        incr_A(x1) = 178
        active#_A(x1) = x1 + 12
        mark_A(x1) = max{138, x1 + 12}
        take_A(x1,x2) = max{129, x1 + 3}
        s_A(x1) = max{134, x1 - 13}
        cons_A(x1,x2) = max{40, x2 - 39}
        pair_A(x1,x2) = max{131, x1, x2 + 5}
        tail_A(x1) = max{358, x1 + 232}
        repItems_A(x1) = x1
        active_A(x1) = max{138, x1}
        pairNs_A = 422
        |0|_A = 135
        oddNs_A = 190
        nil_A = 1
        zip_A(x1,x2) = 37
  
    precedence:
    
      mark# > active# = take = cons = pair > incr > mark = tail = active > s = repItems = pairNs = |0| = oddNs = nil = zip
    
    partial status:
  
      pi(mark#) = []
      pi(incr) = []
      pi(active#) = [1]
      pi(mark) = []
      pi(take) = []
      pi(s) = []
      pi(cons) = []
      pi(pair) = []
      pi(tail) = []
      pi(repItems) = []
      pi(active) = []
      pi(pairNs) = []
      pi(|0|) = []
      pi(oddNs) = []
      pi(nil) = []
      pi(zip) = []

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(incr(X)) -> active#(incr(mark(X)))
p2: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p3: mark#(pair(X1,X2)) -> active#(pair(mark(X1),mark(X2)))
p4: mark#(pair(X1,X2)) -> mark#(X1)
p5: mark#(pair(X1,X2)) -> mark#(X2)
p6: mark#(tail(X)) -> active#(tail(mark(X)))
p7: mark#(tail(X)) -> mark#(X)
p8: mark#(repItems(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p4, p5, p7, p8}


-- Reduction pair.

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

p1: mark#(pair(X1,X2)) -> mark#(X1)
p2: mark#(repItems(X)) -> mark#(X)
p3: mark#(tail(X)) -> mark#(X)
p4: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 1
        pair_A(x1,x2) = max{x1, x2}
        repItems_A(x1) = x1
        tail_A(x1) = x1
  
    precedence:
    
      mark# = pair = repItems = tail
    
    partial status:
  
      pi(mark#) = [1]
      pi(pair) = [1, 2]
      pi(repItems) = [1]
      pi(tail) = [1]

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)
p2: mark#(tail(X)) -> mark#(X)
p3: mark#(pair(X1,X2)) -> mark#(X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: mark#(repItems(X)) -> mark#(X)
p2: mark#(pair(X1,X2)) -> mark#(X2)
p3: mark#(tail(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 2
        repItems_A(x1) = x1
        pair_A(x1,x2) = x2
        tail_A(x1) = x1
  
    precedence:
    
      mark# = repItems = pair = tail
    
    partial status:
  
      pi(mark#) = [1]
      pi(repItems) = [1]
      pi(pair) = [2]
      pi(tail) = [1]

The next rules are strictly ordered:

  p2

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)
p2: mark#(tail(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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#(repItems(X)) -> mark#(X)
p2: mark#(tail(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = max{3, x1 + 2}
        repItems_A(x1) = x1 + 3
        tail_A(x1) = max{1, x1}
  
    precedence:
    
      mark# = repItems = tail
    
    partial status:
  
      pi(mark#) = [1]
      pi(repItems) = [1]
      pi(tail) = [1]

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#(tail(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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#(tail(X)) -> mark#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        mark#_A(x1) = x1 + 2
        tail_A(x1) = x1 + 2
  
    precedence:
    
      mark# = tail
    
    partial status:
  
      pi(mark#) = [1]
      pi(tail) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: cons#(mark(X1),X2) -> cons#(X1,X2)
p2: cons#(X1,active(X2)) -> cons#(X1,X2)
p3: cons#(active(X1),X2) -> cons#(X1,X2)
p4: cons#(X1,mark(X2)) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        cons#_A(x1,x2) = max{0, x2 - 2}
        mark_A(x1) = x1
        active_A(x1) = max{3, x1 + 1}
  
    precedence:
    
      cons# = mark = active
    
    partial status:
  
      pi(cons#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: cons#(mark(X1),X2) -> cons#(X1,X2)
p2: cons#(active(X1),X2) -> cons#(X1,X2)
p3: cons#(X1,mark(X2)) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: cons#(mark(X1),X2) -> cons#(X1,X2)
p2: cons#(X1,mark(X2)) -> cons#(X1,X2)
p3: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        cons#_A(x1,x2) = max{0, x1 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1
  
    precedence:
    
      cons# = mark = active
    
    partial status:
  
      pi(cons#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: cons#(X1,mark(X2)) -> cons#(X1,X2)
p2: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: cons#(X1,mark(X2)) -> cons#(X1,X2)
p2: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        cons#_A(x1,x2) = x2 + 1
        mark_A(x1) = x1 + 1
        active_A(x1) = x1 + 1
  
    precedence:
    
      cons# = mark = active
    
    partial status:
  
      pi(cons#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        cons#_A(x1,x2) = max{1, x1, x2}
        active_A(x1) = x1 + 1
  
    precedence:
    
      cons# = active
    
    partial status:
  
      pi(cons#) = [1, 2]
      pi(active) = []

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: s#(mark(X)) -> s#(X)
p2: s#(active(X)) -> s#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        s#_A(x1) = max{3, x1 + 2}
        mark_A(x1) = x1
        active_A(x1) = x1 + 1
  
    precedence:
    
      s# = mark = active
    
    partial status:
  
      pi(s#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

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: s#(active(X)) -> s#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: s#(active(X)) -> s#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        s#_A(x1) = x1 + 1
        active_A(x1) = x1
  
    precedence:
    
      s# = active
    
    partial status:
  
      pi(s#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: incr#(mark(X)) -> incr#(X)
p2: incr#(active(X)) -> incr#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        incr#_A(x1) = x1 + 1
        mark_A(x1) = x1
        active_A(x1) = x1
  
    precedence:
    
      incr# = mark = active
    
    partial status:
  
      pi(incr#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

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: incr#(active(X)) -> incr#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: incr#(active(X)) -> incr#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        incr#_A(x1) = x1 + 1
        active_A(x1) = x1
  
    precedence:
    
      incr# = active
    
    partial status:
  
      pi(incr#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: take#(mark(X1),X2) -> take#(X1,X2)
p2: take#(X1,active(X2)) -> take#(X1,X2)
p3: take#(active(X1),X2) -> take#(X1,X2)
p4: take#(X1,mark(X2)) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        take#_A(x1,x2) = max{0, x2 - 1}
        mark_A(x1) = x1
        active_A(x1) = x1 + 2
  
    precedence:
    
      take# = mark = active
    
    partial status:
  
      pi(take#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: take#(mark(X1),X2) -> take#(X1,X2)
p2: take#(active(X1),X2) -> take#(X1,X2)
p3: take#(X1,mark(X2)) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: take#(mark(X1),X2) -> take#(X1,X2)
p2: take#(X1,mark(X2)) -> take#(X1,X2)
p3: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        take#_A(x1,x2) = max{0, x1 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1
  
    precedence:
    
      take# = mark = active
    
    partial status:
  
      pi(take#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: take#(X1,mark(X2)) -> take#(X1,X2)
p2: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: take#(X1,mark(X2)) -> take#(X1,X2)
p2: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        take#_A(x1,x2) = max{0, x2 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1 + 1
  
    precedence:
    
      take# = mark = active
    
    partial status:
  
      pi(take#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        take#_A(x1,x2) = max{1, x1, x2}
        active_A(x1) = x1 + 1
  
    precedence:
    
      take# = active
    
    partial status:
  
      pi(take#) = [1, 2]
      pi(active) = []

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: pair#(mark(X1),X2) -> pair#(X1,X2)
p2: pair#(X1,active(X2)) -> pair#(X1,X2)
p3: pair#(active(X1),X2) -> pair#(X1,X2)
p4: pair#(X1,mark(X2)) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        pair#_A(x1,x2) = max{0, x2 - 1}
        mark_A(x1) = x1
        active_A(x1) = x1 + 2
  
    precedence:
    
      pair# = mark = active
    
    partial status:
  
      pi(pair#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: pair#(mark(X1),X2) -> pair#(X1,X2)
p2: pair#(active(X1),X2) -> pair#(X1,X2)
p3: pair#(X1,mark(X2)) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: pair#(mark(X1),X2) -> pair#(X1,X2)
p2: pair#(X1,mark(X2)) -> pair#(X1,X2)
p3: pair#(active(X1),X2) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        pair#_A(x1,x2) = max{0, x1 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1
  
    precedence:
    
      pair# = mark = active
    
    partial status:
  
      pi(pair#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: pair#(X1,mark(X2)) -> pair#(X1,X2)
p2: pair#(active(X1),X2) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: pair#(X1,mark(X2)) -> pair#(X1,X2)
p2: pair#(active(X1),X2) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        pair#_A(x1,x2) = max{0, x2 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1 + 1
  
    precedence:
    
      pair# = mark = active
    
    partial status:
  
      pi(pair#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: pair#(active(X1),X2) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: pair#(active(X1),X2) -> pair#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        pair#_A(x1,x2) = max{1, x1, x2}
        active_A(x1) = x1 + 1
  
    precedence:
    
      pair# = active
    
    partial status:
  
      pi(pair#) = [1, 2]
      pi(active) = []

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: zip#(mark(X1),X2) -> zip#(X1,X2)
p2: zip#(X1,active(X2)) -> zip#(X1,X2)
p3: zip#(active(X1),X2) -> zip#(X1,X2)
p4: zip#(X1,mark(X2)) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        zip#_A(x1,x2) = max{0, x2 - 1}
        mark_A(x1) = x1
        active_A(x1) = x1 + 2
  
    precedence:
    
      zip# = mark = active
    
    partial status:
  
      pi(zip#) = []
      pi(mark) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: zip#(mark(X1),X2) -> zip#(X1,X2)
p2: zip#(active(X1),X2) -> zip#(X1,X2)
p3: zip#(X1,mark(X2)) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3}


-- Reduction pair.

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

p1: zip#(mark(X1),X2) -> zip#(X1,X2)
p2: zip#(X1,mark(X2)) -> zip#(X1,X2)
p3: zip#(active(X1),X2) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        zip#_A(x1,x2) = max{0, x1 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1
  
    precedence:
    
      zip# = mark = active
    
    partial status:
  
      pi(zip#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: zip#(X1,mark(X2)) -> zip#(X1,X2)
p2: zip#(active(X1),X2) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: zip#(X1,mark(X2)) -> zip#(X1,X2)
p2: zip#(active(X1),X2) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        zip#_A(x1,x2) = max{0, x2 - 2}
        mark_A(x1) = max{3, x1 + 1}
        active_A(x1) = x1 + 1
  
    precedence:
    
      zip# = mark = active
    
    partial status:
  
      pi(zip#) = []
      pi(mark) = [1]
      pi(active) = [1]

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: zip#(active(X1),X2) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: zip#(active(X1),X2) -> zip#(X1,X2)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        zip#_A(x1,x2) = max{1, x1, x2}
        active_A(x1) = x1 + 1
  
    precedence:
    
      zip# = active
    
    partial status:
  
      pi(zip#) = [1, 2]
      pi(active) = []

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        repItems#_A(x1) = max{3, x1 + 2}
        mark_A(x1) = x1
        active_A(x1) = x1 + 1
  
    precedence:
    
      repItems# = mark = active
    
    partial status:
  
      pi(repItems#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

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: repItems#(active(X)) -> repItems#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: repItems#(active(X)) -> repItems#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        repItems#_A(x1) = x1 + 1
        active_A(x1) = x1
  
    precedence:
    
      repItems# = active
    
    partial status:
  
      pi(repItems#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: tail#(mark(X)) -> tail#(X)
p2: tail#(active(X)) -> tail#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        tail#_A(x1) = max{3, x1 + 2}
        mark_A(x1) = x1
        active_A(x1) = x1 + 1
  
    precedence:
    
      tail# = mark = active
    
    partial status:
  
      pi(tail#) = [1]
      pi(mark) = [1]
      pi(active) = [1]

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: tail#(active(X)) -> tail#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(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: tail#(active(X)) -> tail#(X)

and R consists of:

r1: active(pairNs()) -> mark(cons(|0|(),incr(oddNs())))
r2: active(oddNs()) -> mark(incr(pairNs()))
r3: active(incr(cons(X,XS))) -> mark(cons(s(X),incr(XS)))
r4: active(take(|0|(),XS)) -> mark(nil())
r5: active(take(s(N),cons(X,XS))) -> mark(cons(X,take(N,XS)))
r6: active(zip(nil(),XS)) -> mark(nil())
r7: active(zip(X,nil())) -> mark(nil())
r8: active(zip(cons(X,XS),cons(Y,YS))) -> mark(cons(pair(X,Y),zip(XS,YS)))
r9: active(tail(cons(X,XS))) -> mark(XS)
r10: active(repItems(nil())) -> mark(nil())
r11: active(repItems(cons(X,XS))) -> mark(cons(X,cons(X,repItems(XS))))
r12: mark(pairNs()) -> active(pairNs())
r13: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r14: mark(|0|()) -> active(|0|())
r15: mark(incr(X)) -> active(incr(mark(X)))
r16: mark(oddNs()) -> active(oddNs())
r17: mark(s(X)) -> active(s(mark(X)))
r18: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r19: mark(nil()) -> active(nil())
r20: mark(zip(X1,X2)) -> active(zip(mark(X1),mark(X2)))
r21: mark(pair(X1,X2)) -> active(pair(mark(X1),mark(X2)))
r22: mark(tail(X)) -> active(tail(mark(X)))
r23: mark(repItems(X)) -> active(repItems(mark(X)))
r24: cons(mark(X1),X2) -> cons(X1,X2)
r25: cons(X1,mark(X2)) -> cons(X1,X2)
r26: cons(active(X1),X2) -> cons(X1,X2)
r27: cons(X1,active(X2)) -> cons(X1,X2)
r28: incr(mark(X)) -> incr(X)
r29: incr(active(X)) -> incr(X)
r30: s(mark(X)) -> s(X)
r31: s(active(X)) -> s(X)
r32: take(mark(X1),X2) -> take(X1,X2)
r33: take(X1,mark(X2)) -> take(X1,X2)
r34: take(active(X1),X2) -> take(X1,X2)
r35: take(X1,active(X2)) -> take(X1,X2)
r36: zip(mark(X1),X2) -> zip(X1,X2)
r37: zip(X1,mark(X2)) -> zip(X1,X2)
r38: zip(active(X1),X2) -> zip(X1,X2)
r39: zip(X1,active(X2)) -> zip(X1,X2)
r40: pair(mark(X1),X2) -> pair(X1,X2)
r41: pair(X1,mark(X2)) -> pair(X1,X2)
r42: pair(active(X1),X2) -> pair(X1,X2)
r43: pair(X1,active(X2)) -> pair(X1,X2)
r44: tail(mark(X)) -> tail(X)
r45: tail(active(X)) -> tail(X)
r46: repItems(mark(X)) -> repItems(X)
r47: repItems(active(X)) -> repItems(X)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        tail#_A(x1) = x1 + 1
        active_A(x1) = x1
  
    precedence:
    
      tail# = active
    
    partial status:
  
      pi(tail#) = [1]
      pi(active) = [1]

The next rules are strictly ordered:

  p1

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