YES

We show the termination of the TRS R:

  a__and(tt(),T) -> mark(T)
  a__isNatIList(IL) -> a__isNatList(IL)
  a__isNat(|0|()) -> tt()
  a__isNat(s(N)) -> a__isNat(N)
  a__isNat(length(L)) -> a__isNatList(L)
  a__isNatIList(zeros()) -> tt()
  a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
  a__isNatList(nil()) -> tt()
  a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
  a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
  a__zeros() -> cons(|0|(),zeros())
  a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
  a__uTake1(tt()) -> nil()
  a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
  a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
  a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
  a__uLength(tt(),L) -> s(a__length(mark(L)))
  mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
  mark(isNatIList(X)) -> a__isNatIList(X)
  mark(isNatList(X)) -> a__isNatList(X)
  mark(isNat(X)) -> a__isNat(X)
  mark(length(X)) -> a__length(mark(X))
  mark(zeros()) -> a__zeros()
  mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
  mark(uTake1(X)) -> a__uTake1(mark(X))
  mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
  mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
  mark(tt()) -> tt()
  mark(|0|()) -> |0|()
  mark(s(X)) -> s(mark(X))
  mark(cons(X1,X2)) -> cons(mark(X1),X2)
  mark(nil()) -> nil()
  a__and(X1,X2) -> and(X1,X2)
  a__isNatIList(X) -> isNatIList(X)
  a__isNatList(X) -> isNatList(X)
  a__isNat(X) -> isNat(X)
  a__length(X) -> length(X)
  a__zeros() -> zeros()
  a__take(X1,X2) -> take(X1,X2)
  a__uTake1(X) -> uTake1(X)
  a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
  a__uLength(X1,X2) -> uLength(X1,X2)

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: a__isNatIList#(IL) -> a__isNatList#(IL)
p3: a__isNat#(s(N)) -> a__isNat#(N)
p4: a__isNat#(length(L)) -> a__isNatList#(L)
p5: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p6: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p7: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p8: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p9: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p10: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p11: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p12: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p13: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p14: a__take#(|0|(),IL) -> a__uTake1#(a__isNatIList(IL))
p15: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p16: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p17: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p18: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p19: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p21: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p22: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p23: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p24: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p25: a__length#(cons(N,L)) -> a__isNat#(N)
p26: a__length#(cons(N,L)) -> a__isNatList#(L)
p27: a__uLength#(tt(),L) -> a__length#(mark(L))
p28: a__uLength#(tt(),L) -> mark#(L)
p29: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p30: mark#(and(X1,X2)) -> mark#(X1)
p31: mark#(and(X1,X2)) -> mark#(X2)
p32: mark#(isNatIList(X)) -> a__isNatIList#(X)
p33: mark#(isNatList(X)) -> a__isNatList#(X)
p34: mark#(isNat(X)) -> a__isNat#(X)
p35: mark#(length(X)) -> a__length#(mark(X))
p36: mark#(length(X)) -> mark#(X)
p37: mark#(zeros()) -> a__zeros#()
p38: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p39: mark#(take(X1,X2)) -> mark#(X1)
p40: mark#(take(X1,X2)) -> mark#(X2)
p41: mark#(uTake1(X)) -> a__uTake1#(mark(X))
p42: mark#(uTake1(X)) -> mark#(X)
p43: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p44: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p45: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p46: mark#(uLength(X1,X2)) -> mark#(X1)
p47: mark#(s(X)) -> mark#(X)
p48: mark#(cons(X1,X2)) -> mark#(X1)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p38, p39, p40, p42, p43, p44, p45, p46, p47, p48}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(cons(X1,X2)) -> mark#(X1)
p3: mark#(s(X)) -> mark#(X)
p4: mark#(uLength(X1,X2)) -> mark#(X1)
p5: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p6: a__uLength#(tt(),L) -> mark#(L)
p7: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p8: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p9: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p10: mark#(uTake1(X)) -> mark#(X)
p11: mark#(take(X1,X2)) -> mark#(X2)
p12: mark#(take(X1,X2)) -> mark#(X1)
p13: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p14: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p17: a__isNat#(length(L)) -> a__isNatList#(L)
p18: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p19: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatIList#(IL) -> a__isNatList#(IL)
p21: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p22: a__isNat#(s(N)) -> a__isNat#(N)
p23: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p25: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p26: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p27: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p28: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p29: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p30: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p31: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p32: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p33: mark#(length(X)) -> mark#(X)
p34: mark#(length(X)) -> a__length#(mark(X))
p35: a__length#(cons(N,L)) -> a__isNatList#(L)
p36: a__length#(cons(N,L)) -> a__isNat#(N)
p37: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p38: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p39: a__uLength#(tt(),L) -> a__length#(mark(L))
p40: mark#(isNat(X)) -> a__isNat#(X)
p41: mark#(isNatList(X)) -> a__isNatList#(X)
p42: mark#(isNatIList(X)) -> a__isNatIList#(X)
p43: mark#(and(X1,X2)) -> mark#(X2)
p44: mark#(and(X1,X2)) -> mark#(X1)
p45: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 19, x2 + 19}
        tt_A = 0
        mark#_A(x1) = x1 + 19
        cons_A(x1,x2) = max{x1 + 33, x2}
        s_A(x1) = max{33, x1}
        uLength_A(x1,x2) = max{33, x1, x2 + 27}
        a__uLength#_A(x1,x2) = max{x1 + 8, x2 + 45}
        mark_A(x1) = x1
        uTake2_A(x1,x2,x3,x4) = max{53, x1, x2 + 52, x3 + 36, x4 + 52}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 + 19, x2 + 38, x3 + 55, x4 + 71}
        uTake1_A(x1) = max{38, x1}
        take_A(x1,x2) = max{x1 + 52, x2 + 52}
        a__take#_A(x1,x2) = max{x1 + 38, x2 + 71}
        a__isNatIList#_A(x1) = x1 + 50
        a__isNat#_A(x1) = x1 + 18
        length_A(x1) = x1 + 27
        a__isNatList#_A(x1) = x1 + 45
        a__isNat_A(x1) = max{16, x1 - 1}
        a__isNatIList_A(x1) = max{32, x1 + 31}
        a__isNatList_A(x1) = x1 + 26
        a__and_A(x1,x2) = max{59, x1 + 20, x2}
        |0|_A = 13
        a__length#_A(x1) = x1 + 45
        isNat_A(x1) = max{16, x1 - 1}
        isNatList_A(x1) = x1 + 26
        isNatIList_A(x1) = max{32, x1 + 31}
        and_A(x1,x2) = max{59, x1 + 20, x2}
        a__zeros_A = 47
        zeros_A = 47
        a__take_A(x1,x2) = max{x1 + 52, x2 + 52}
        a__uTake1_A(x1) = max{38, x1}
        nil_A = 1
        a__uTake2_A(x1,x2,x3,x4) = max{53, x1, x2 + 52, x3 + 36, x4 + 52}
        a__length_A(x1) = x1 + 27
        a__uLength_A(x1,x2) = max{33, x1, x2 + 27}
  
    precedence:
    
      tt = a__isNatIList = isNatIList = nil > a__and# = mark# = a__uLength# = a__isNatIList# = a__isNat# = a__isNatList# = a__length# > a__isNat = isNat > a__isNatList = isNatList > mark = a__and = and = a__length > a__zeros > a__take > uTake2 = a__uTake2 > cons > take > s = uLength = a__uTake2# = a__take# = length = zeros = a__uLength > uTake1 = a__uTake1 > |0|
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(cons) = [2]
      pi(s) = []
      pi(uLength) = [1]
      pi(a__uLength#) = []
      pi(mark) = [1]
      pi(uTake2) = []
      pi(a__uTake2#) = []
      pi(uTake1) = []
      pi(take) = [1, 2]
      pi(a__take#) = []
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = [1]
      pi(a__isNatList) = [1]
      pi(a__and) = [2]
      pi(|0|) = []
      pi(a__length#) = []
      pi(isNat) = []
      pi(isNatList) = [1]
      pi(isNatIList) = [1]
      pi(and) = [2]
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = [2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = [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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p18: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p19: a__isNatIList#(IL) -> a__isNatList#(IL)
p20: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p21: a__isNat#(s(N)) -> a__isNat#(N)
p22: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p23: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p24: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p25: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p26: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p27: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p28: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p29: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p30: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p31: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p32: mark#(length(X)) -> mark#(X)
p33: mark#(length(X)) -> a__length#(mark(X))
p34: a__length#(cons(N,L)) -> a__isNatList#(L)
p35: a__length#(cons(N,L)) -> a__isNat#(N)
p36: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p37: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p38: a__uLength#(tt(),L) -> a__length#(mark(L))
p39: mark#(isNat(X)) -> a__isNat#(X)
p40: mark#(isNatList(X)) -> a__isNatList#(X)
p41: mark#(isNatIList(X)) -> a__isNatIList#(X)
p42: mark#(and(X1,X2)) -> mark#(X2)
p43: mark#(and(X1,X2)) -> mark#(X1)
p44: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, p44}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p16: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p17: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p18: mark#(isNatList(X)) -> a__isNatList#(X)
p19: mark#(isNat(X)) -> a__isNat#(X)
p20: mark#(length(X)) -> a__length#(mark(X))
p21: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p22: a__uLength#(tt(),L) -> a__length#(mark(L))
p23: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p24: a__length#(cons(N,L)) -> a__isNat#(N)
p25: a__length#(cons(N,L)) -> a__isNatList#(L)
p26: a__uLength#(tt(),L) -> mark#(L)
p27: mark#(length(X)) -> mark#(X)
p28: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p29: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p30: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p31: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p32: mark#(take(X1,X2)) -> mark#(X1)
p33: mark#(take(X1,X2)) -> mark#(X2)
p34: mark#(uTake1(X)) -> mark#(X)
p35: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p36: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p37: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p38: mark#(uLength(X1,X2)) -> mark#(X1)
p39: mark#(s(X)) -> mark#(X)
p40: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p41: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p42: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p43: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p44: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 38, x2 + 38}
        tt_A = 9
        mark#_A(x1) = max{47, x1 + 38}
        and_A(x1,x2) = max{x1, x2}
        mark_A(x1) = max{9, x1}
        isNatIList_A(x1) = max{158, x1 + 44}
        a__isNatIList#_A(x1) = x1 + 82
        a__isNatList#_A(x1) = x1 + 62
        cons_A(x1,x2) = max{114, x1 - 10, x2}
        a__isNat_A(x1) = max{12, x1 + 7}
        a__isNatList_A(x1) = x1 + 24
        a__isNat#_A(x1) = max{48, x1}
        s_A(x1) = max{164, x1}
        length_A(x1) = max{175, x1 + 165}
        take_A(x1,x2) = max{197, x1 + 97, x2 + 133}
        a__isNatIList_A(x1) = max{158, x1 + 44}
        isNatList_A(x1) = x1 + 24
        isNat_A(x1) = max{12, x1 + 7}
        a__length#_A(x1) = x1 + 63
        a__uLength#_A(x1,x2) = max{177, x1 - 23, x2 + 63}
        a__and_A(x1,x2) = max{2, x1, x2}
        a__take#_A(x1,x2) = max{x1 + 49, x2 + 87}
        |0|_A = 1
        a__uTake2#_A(x1,x2,x3,x4) = max{x2 + 48, x3 + 76, x4 + 86}
        uTake1_A(x1) = max{1, x1}
        uTake2_A(x1,x2,x3,x4) = max{197, x1 + 89, x2 + 97, x3 + 123, x4 + 133}
        uLength_A(x1,x2) = max{176, x1 + 140, x2 + 165}
        a__zeros_A = 115
        zeros_A = 115
        a__take_A(x1,x2) = max{197, x1 + 97, x2 + 133}
        a__uTake1_A(x1) = max{8, x1}
        nil_A = 7
        a__uTake2_A(x1,x2,x3,x4) = max{197, x1 + 89, x2 + 97, x3 + 123, x4 + 133}
        a__length_A(x1) = max{175, x1 + 165}
        a__uLength_A(x1,x2) = max{176, x1 + 140, x2 + 165}
  
    precedence:
    
      a__take# = a__uTake2# > mark = a__isNatList = a__isNatIList = a__and > a__zeros = zeros > isNatIList > a__take > isNatList = a__uTake2 > |0| > cons > a__isNat > isNat > a__and# = mark# = a__isNatIList# = a__isNatList# > a__length > a__uLength > s > tt = uTake2 > uLength > a__length# = a__uLength# > take > length > a__uTake1 > nil > a__isNat# > and > uTake1
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = [1]
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(isNat) = []
      pi(a__length#) = []
      pi(a__uLength#) = []
      pi(a__and) = []
      pi(a__take#) = [2]
      pi(|0|) = []
      pi(a__uTake2#) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = [2]
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = [1]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p42

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p16: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p17: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p18: mark#(isNatList(X)) -> a__isNatList#(X)
p19: mark#(isNat(X)) -> a__isNat#(X)
p20: mark#(length(X)) -> a__length#(mark(X))
p21: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p22: a__uLength#(tt(),L) -> a__length#(mark(L))
p23: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p24: a__length#(cons(N,L)) -> a__isNat#(N)
p25: a__length#(cons(N,L)) -> a__isNatList#(L)
p26: a__uLength#(tt(),L) -> mark#(L)
p27: mark#(length(X)) -> mark#(X)
p28: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p29: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p30: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p31: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p32: mark#(take(X1,X2)) -> mark#(X1)
p33: mark#(take(X1,X2)) -> mark#(X2)
p34: mark#(uTake1(X)) -> mark#(X)
p35: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p36: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p37: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p38: mark#(uLength(X1,X2)) -> mark#(X1)
p39: mark#(s(X)) -> mark#(X)
p40: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p41: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p42: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p43: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p18: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p19: a__isNatIList#(IL) -> a__isNatList#(IL)
p20: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p21: a__isNat#(s(N)) -> a__isNat#(N)
p22: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p23: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p24: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p25: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p26: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p27: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p28: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p29: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p30: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p31: mark#(length(X)) -> mark#(X)
p32: mark#(length(X)) -> a__length#(mark(X))
p33: a__length#(cons(N,L)) -> a__isNatList#(L)
p34: a__length#(cons(N,L)) -> a__isNat#(N)
p35: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p36: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p37: a__uLength#(tt(),L) -> a__length#(mark(L))
p38: mark#(isNat(X)) -> a__isNat#(X)
p39: mark#(isNatList(X)) -> a__isNatList#(X)
p40: mark#(isNatIList(X)) -> a__isNatIList#(X)
p41: mark#(and(X1,X2)) -> mark#(X2)
p42: mark#(and(X1,X2)) -> mark#(X1)
p43: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{71, x1 + 46, x2 + 52}
        tt_A = 26
        mark#_A(x1) = max{71, x1 + 52}
        s_A(x1) = max{37, x1}
        uLength_A(x1,x2) = max{84, x1 + 47, x2 + 64}
        a__uLength#_A(x1,x2) = max{98, x1 + 61, x2 + 78}
        mark_A(x1) = max{19, x1}
        uTake2_A(x1,x2,x3,x4) = max{179, x1 + 72, x2 + 141, x3 + 92, x4 + 160}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 - 1, x2 + 121, x3 + 100, x4 + 160}
        uTake1_A(x1) = max{71, x1}
        take_A(x1,x2) = max{179, x1 + 141, x2 + 160}
        a__take#_A(x1,x2) = max{x1 + 121, x2 + 160}
        cons_A(x1,x2) = max{8, x1 - 59, x2}
        a__isNatIList#_A(x1) = x1 + 139
        a__isNat#_A(x1) = max{2, x1}
        length_A(x1) = max{84, x1 + 64}
        a__isNatList#_A(x1) = x1 + 63
        a__isNat_A(x1) = max{16, x1 - 49}
        a__isNatIList_A(x1) = x1 + 87
        a__isNatList_A(x1) = max{16, x1 + 11}
        a__and_A(x1,x2) = max{18, x1, x2}
        |0|_A = 76
        a__length#_A(x1) = max{98, x1 + 78}
        isNat_A(x1) = max{16, x1 - 49}
        isNatList_A(x1) = max{15, x1 + 11}
        isNatIList_A(x1) = x1 + 87
        and_A(x1,x2) = max{17, x1, x2}
        a__zeros_A = 18
        zeros_A = 17
        a__take_A(x1,x2) = max{179, x1 + 141, x2 + 160}
        a__uTake1_A(x1) = max{71, x1}
        nil_A = 18
        a__uTake2_A(x1,x2,x3,x4) = max{179, x1 + 72, x2 + 141, x3 + 92, x4 + 160}
        a__length_A(x1) = max{84, x1 + 64}
        a__uLength_A(x1,x2) = max{84, x1 + 47, x2 + 64}
  
    precedence:
    
      a__take# > a__and# = mark# = a__isNatIList# = a__isNatList# > a__uLength# = a__length# > tt = mark = cons = a__isNat = a__isNatIList = a__isNatList = a__and = and = a__take = a__uTake2 > isNatList > a__zeros > length = a__length > a__uLength > isNat > nil > s = a__uTake2# = take > uTake2 > uLength = a__isNat# > a__uTake1 > |0| > uTake1 = isNatIList = zeros
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = []
      pi(a__uTake2#) = []
      pi(uTake1) = []
      pi(take) = [1]
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList) = []
      pi(a__and) = []
      pi(|0|) = []
      pi(a__length#) = []
      pi(isNat) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p32

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p18: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p19: a__isNatIList#(IL) -> a__isNatList#(IL)
p20: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p21: a__isNat#(s(N)) -> a__isNat#(N)
p22: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p23: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p24: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p25: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p26: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p27: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p28: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p29: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p30: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p31: mark#(length(X)) -> mark#(X)
p32: a__length#(cons(N,L)) -> a__isNatList#(L)
p33: a__length#(cons(N,L)) -> a__isNat#(N)
p34: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p35: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p36: a__uLength#(tt(),L) -> a__length#(mark(L))
p37: mark#(isNat(X)) -> a__isNat#(X)
p38: mark#(isNatList(X)) -> a__isNatList#(X)
p39: mark#(isNatIList(X)) -> a__isNatIList#(X)
p40: mark#(and(X1,X2)) -> mark#(X2)
p41: mark#(and(X1,X2)) -> mark#(X1)
p42: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatList#(take(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p16: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p17: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p18: mark#(isNatList(X)) -> a__isNatList#(X)
p19: mark#(isNat(X)) -> a__isNat#(X)
p20: mark#(length(X)) -> mark#(X)
p21: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p22: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p23: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p24: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p25: mark#(take(X1,X2)) -> mark#(X1)
p26: mark#(take(X1,X2)) -> mark#(X2)
p27: mark#(uTake1(X)) -> mark#(X)
p28: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p29: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p30: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p31: a__uLength#(tt(),L) -> a__length#(mark(L))
p32: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p33: a__uLength#(tt(),L) -> mark#(L)
p34: mark#(uLength(X1,X2)) -> mark#(X1)
p35: mark#(s(X)) -> mark#(X)
p36: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p37: a__length#(cons(N,L)) -> a__isNat#(N)
p38: a__length#(cons(N,L)) -> a__isNatList#(L)
p39: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p40: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p41: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p42: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{29, x1 + 6, x2 + 8}
        tt_A = 10
        mark#_A(x1) = max{29, x1 + 8}
        and_A(x1,x2) = max{20, x1, x2}
        mark_A(x1) = max{21, x1}
        isNatIList_A(x1) = max{30, x1 - 8}
        a__isNatIList#_A(x1) = max{38, x1}
        a__isNatList#_A(x1) = max{29, x1}
        cons_A(x1,x2) = max{13, x1, x2}
        a__isNat_A(x1) = max{8, x1 - 8}
        a__isNatList_A(x1) = max{21, x1 - 8}
        a__isNat#_A(x1) = x1
        s_A(x1) = max{17, x1}
        length_A(x1) = max{30, x1}
        take_A(x1,x2) = max{59, x1, x2 + 37}
        a__isNatIList_A(x1) = max{30, x1 - 8}
        isNatList_A(x1) = max{21, x1 - 8}
        isNat_A(x1) = max{8, x1 - 8}
        a__take#_A(x1,x2) = max{x1 + 7, x2 + 44}
        |0|_A = 19
        a__uTake2#_A(x1,x2,x3,x4) = max{57, x1 - 24, x2 + 7, x3 + 44, x4 + 44}
        a__and_A(x1,x2) = max{21, x1, x2}
        uTake1_A(x1) = x1
        uTake2_A(x1,x2,x3,x4) = max{59, x1 + 4, x2, x3 + 37, x4 + 37}
        uLength_A(x1,x2) = max{30, x1 + 8, x2}
        a__uLength#_A(x1,x2) = max{38, x2 + 8}
        a__length#_A(x1) = max{38, x1 + 8}
        a__zeros_A = 20
        zeros_A = 20
        a__take_A(x1,x2) = max{59, x1, x2 + 37}
        a__uTake1_A(x1) = max{20, x1}
        nil_A = 19
        a__uTake2_A(x1,x2,x3,x4) = max{59, x1 + 4, x2, x3 + 37, x4 + 37}
        a__length_A(x1) = max{30, x1}
        a__uLength_A(x1,x2) = max{30, x1 + 8, x2}
  
    precedence:
    
      a__zeros > nil > tt = and = mark = isNatIList = a__isNat = a__isNatList = a__isNatIList = isNatList = isNat = a__and = uTake1 = zeros = a__uTake1 > a__take > |0| = uTake2 = a__uTake2 > s = length = uLength = a__length = a__uLength > a__and# = mark# = a__isNatIList# = a__isNatList# = cons = a__isNat# = a__uLength# = a__length# > a__take# = a__uTake2# > take
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = []
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(isNat) = []
      pi(a__take#) = [1, 2]
      pi(|0|) = []
      pi(a__uTake2#) = []
      pi(a__and) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p22: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p23: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p24: mark#(take(X1,X2)) -> mark#(X1)
p25: mark#(take(X1,X2)) -> mark#(X2)
p26: mark#(uTake1(X)) -> mark#(X)
p27: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p28: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p29: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p30: a__uLength#(tt(),L) -> a__length#(mark(L))
p31: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p32: a__uLength#(tt(),L) -> mark#(L)
p33: mark#(uLength(X1,X2)) -> mark#(X1)
p34: mark#(s(X)) -> mark#(X)
p35: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p36: a__length#(cons(N,L)) -> a__isNat#(N)
p37: a__length#(cons(N,L)) -> a__isNatList#(L)
p38: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p39: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p40: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p41: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p18: a__isNat#(s(N)) -> a__isNat#(N)
p19: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p21: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p22: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p23: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatIList#(IL) -> a__isNatList#(IL)
p25: a__take#(s(M),cons(N,IL)) -> a__isNat#(N)
p26: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p27: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p28: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p29: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p30: mark#(length(X)) -> mark#(X)
p31: mark#(isNat(X)) -> a__isNat#(X)
p32: mark#(isNatList(X)) -> a__isNatList#(X)
p33: mark#(isNatIList(X)) -> a__isNatIList#(X)
p34: mark#(and(X1,X2)) -> mark#(X2)
p35: mark#(and(X1,X2)) -> mark#(X1)
p36: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p37: a__uLength#(tt(),L) -> a__length#(mark(L))
p38: a__length#(cons(N,L)) -> a__isNatList#(L)
p39: a__length#(cons(N,L)) -> a__isNat#(N)
p40: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p41: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1, x2 + 84}
        tt_A = 22
        mark#_A(x1) = x1 + 84
        s_A(x1) = x1
        uLength_A(x1,x2) = max{123, x1 + 88, x2 + 117}
        a__uLength#_A(x1,x2) = max{171, x1 + 119, x2 + 165}
        mark_A(x1) = max{5, x1}
        uTake2_A(x1,x2,x3,x4) = max{129, x1, x2 + 112, x3 + 2, x4 + 118}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 + 30, x2 + 125, x3 + 85, x4 + 119}
        uTake1_A(x1) = max{128, x1 + 85}
        take_A(x1,x2) = max{129, x1 + 112, x2 + 118}
        a__take#_A(x1,x2) = max{x1 + 125, x2 + 125}
        cons_A(x1,x2) = max{3, x1 - 13, x2}
        a__isNatIList#_A(x1) = x1 + 117
        a__isNat#_A(x1) = max{36, x1 - 7}
        length_A(x1) = max{123, x1 + 117}
        a__isNatList#_A(x1) = max{116, x1 + 110}
        a__isNat_A(x1) = x1 + 6
        a__isNatIList_A(x1) = x1 + 33
        a__isNatList_A(x1) = max{32, x1 + 26}
        a__and_A(x1,x2) = max{12, x1 + 6, x2}
        |0|_A = 16
        isNat_A(x1) = x1 + 6
        isNatList_A(x1) = max{32, x1 + 26}
        isNatIList_A(x1) = x1 + 33
        and_A(x1,x2) = max{12, x1 + 6, x2}
        a__length#_A(x1) = max{171, x1 + 165}
        a__zeros_A = 4
        zeros_A = 3
        a__take_A(x1,x2) = max{129, x1 + 112, x2 + 118}
        a__uTake1_A(x1) = max{128, x1 + 85}
        nil_A = 6
        a__uTake2_A(x1,x2,x3,x4) = max{129, x1, x2 + 112, x3 + 2, x4 + 118}
        a__length_A(x1) = max{123, x1 + 117}
        a__uLength_A(x1,x2) = max{123, x1 + 88, x2 + 117}
  
    precedence:
    
      zeros > nil > a__isNatIList = a__isNatList = isNatList = isNatIList > a__zeros > |0| > a__take# > a__uLength# = a__length# > a__isNat# > a__and# = mark# = a__isNatIList# = length = a__isNatList# = a__length > uLength = mark = uTake1 = a__and = and = a__take = a__uTake1 = a__uLength > a__uTake2 > cons > s > take > tt = uTake2 = a__uTake2# = a__isNat = isNat
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = [1]
      pi(uTake2) = [1]
      pi(a__uTake2#) = [2, 4]
      pi(uTake1) = []
      pi(take) = []
      pi(a__take#) = [1, 2]
      pi(cons) = [2]
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = [1]
      pi(a__isNatList) = [1]
      pi(a__and) = [2]
      pi(|0|) = []
      pi(isNat) = []
      pi(isNatList) = [1]
      pi(isNatIList) = [1]
      pi(and) = [2]
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [1]
      pi(a__length) = []
      pi(a__uLength) = [1]

The next rules are strictly ordered:

  p25

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p18: a__isNat#(s(N)) -> a__isNat#(N)
p19: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p21: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p22: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p23: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatIList#(IL) -> a__isNatList#(IL)
p25: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p26: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p27: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p28: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p29: mark#(length(X)) -> mark#(X)
p30: mark#(isNat(X)) -> a__isNat#(X)
p31: mark#(isNatList(X)) -> a__isNatList#(X)
p32: mark#(isNatIList(X)) -> a__isNatIList#(X)
p33: mark#(and(X1,X2)) -> mark#(X2)
p34: mark#(and(X1,X2)) -> mark#(X1)
p35: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p36: a__uLength#(tt(),L) -> a__length#(mark(L))
p37: a__length#(cons(N,L)) -> a__isNatList#(L)
p38: a__length#(cons(N,L)) -> a__isNat#(N)
p39: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p40: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p22: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p23: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p24: mark#(take(X1,X2)) -> mark#(X1)
p25: mark#(take(X1,X2)) -> mark#(X2)
p26: mark#(uTake1(X)) -> mark#(X)
p27: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p28: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p29: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p30: a__uLength#(tt(),L) -> a__length#(mark(L))
p31: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p32: a__uLength#(tt(),L) -> mark#(L)
p33: mark#(uLength(X1,X2)) -> mark#(X1)
p34: mark#(s(X)) -> mark#(X)
p35: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p36: a__length#(cons(N,L)) -> a__isNat#(N)
p37: a__length#(cons(N,L)) -> a__isNatList#(L)
p38: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p39: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p40: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{113, x1 - 43, x2 + 42}
        tt_A = 25
        mark#_A(x1) = max{113, x1 + 42}
        and_A(x1,x2) = max{1, x1, x2}
        mark_A(x1) = max{25, x1}
        isNatIList_A(x1) = 0
        a__isNatIList#_A(x1) = 113
        a__isNatList#_A(x1) = 113
        cons_A(x1,x2) = max{6, x1 - 17, x2}
        a__isNat_A(x1) = 25
        a__isNatList_A(x1) = 25
        a__isNat#_A(x1) = 113
        s_A(x1) = x1
        length_A(x1) = max{112, x1 + 75}
        take_A(x1,x2) = max{71, x1 + 43, x2 + 46}
        a__isNatIList_A(x1) = 25
        isNatList_A(x1) = 25
        isNat_A(x1) = 25
        a__take#_A(x1,x2) = max{113, x2 + 88}
        |0|_A = 31
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 + 88, x3 + 67, x4 + 87}
        a__and_A(x1,x2) = max{2, x1, x2}
        uTake1_A(x1) = max{73, x1 + 47}
        uTake2_A(x1,x2,x3,x4) = max{71, x1 + 46, x2 + 43, x3 + 26, x4 + 46}
        uLength_A(x1,x2) = max{112, x1 + 72, x2 + 75}
        a__uLength#_A(x1,x2) = max{111, x1 + 88, x2 + 85}
        a__length#_A(x1) = max{113, x1 + 85}
        a__zeros_A = 15
        zeros_A = 0
        a__take_A(x1,x2) = max{71, x1 + 43, x2 + 46}
        a__uTake1_A(x1) = max{73, x1 + 47}
        nil_A = 24
        a__uTake2_A(x1,x2,x3,x4) = max{71, x1 + 46, x2 + 43, x3 + 26, x4 + 46}
        a__length_A(x1) = max{112, x1 + 75}
        a__uLength_A(x1,x2) = max{112, x1 + 72, x2 + 75}
  
    precedence:
    
      a__uLength# = a__length# > a__and# = mark# = a__isNatIList# = a__isNatList# = a__isNat# = a__take# = a__uTake2# > mark = a__isNat = a__isNatList = a__isNatIList = isNat = a__and = nil > a__length > a__uLength > |0| > a__take > and = zeros > isNatIList = a__zeros > s > uTake2 = a__uTake2 > take > tt > isNatList > length = uLength > a__uTake1 > cons = uTake1
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = [2]
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(isNat) = []
      pi(a__take#) = []
      pi(|0|) = []
      pi(a__uTake2#) = []
      pi(a__and) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = [2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p36

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p22: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p23: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p24: mark#(take(X1,X2)) -> mark#(X1)
p25: mark#(take(X1,X2)) -> mark#(X2)
p26: mark#(uTake1(X)) -> mark#(X)
p27: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p28: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p29: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p30: a__uLength#(tt(),L) -> a__length#(mark(L))
p31: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p32: a__uLength#(tt(),L) -> mark#(L)
p33: mark#(uLength(X1,X2)) -> mark#(X1)
p34: mark#(s(X)) -> mark#(X)
p35: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p36: a__length#(cons(N,L)) -> a__isNatList#(L)
p37: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p38: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p39: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p18: a__isNat#(s(N)) -> a__isNat#(N)
p19: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p21: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p22: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p23: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatIList#(IL) -> a__isNatList#(IL)
p25: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p26: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p27: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p28: a__take#(|0|(),IL) -> a__isNatIList#(IL)
p29: mark#(length(X)) -> mark#(X)
p30: mark#(isNat(X)) -> a__isNat#(X)
p31: mark#(isNatList(X)) -> a__isNatList#(X)
p32: mark#(isNatIList(X)) -> a__isNatIList#(X)
p33: mark#(and(X1,X2)) -> mark#(X2)
p34: mark#(and(X1,X2)) -> mark#(X1)
p35: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p36: a__uLength#(tt(),L) -> a__length#(mark(L))
p37: a__length#(cons(N,L)) -> a__isNatList#(L)
p38: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p39: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{24, x2 + 3}
        tt_A = 6
        mark#_A(x1) = max{24, x1 + 3}
        s_A(x1) = max{5, x1}
        uLength_A(x1,x2) = max{53, x1 + 45, x2 + 47}
        a__uLength#_A(x1,x2) = max{x1 + 38, x2 + 38}
        mark_A(x1) = max{6, x1}
        uTake2_A(x1,x2,x3,x4) = max{21, x1 + 15, x2 + 15, x3 + 2, x4 + 15}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 + 18, x2 + 10, x3 + 4, x4 - 1}
        uTake1_A(x1) = max{20, x1}
        take_A(x1,x2) = max{21, x1 + 15, x2 + 15}
        a__take#_A(x1,x2) = max{24, x1 + 10, x2 + 18}
        cons_A(x1,x2) = max{3, x1 - 12, x2}
        a__isNatIList#_A(x1) = max{24, x1 + 1}
        a__isNat#_A(x1) = max{24, x1 - 58}
        length_A(x1) = max{53, x1 + 47}
        a__isNatList#_A(x1) = max{24, x1 - 13}
        a__isNat_A(x1) = max{6, x1 - 58}
        a__isNatIList_A(x1) = max{6, x1 - 2}
        a__isNatList_A(x1) = max{6, x1 - 16}
        a__and_A(x1,x2) = max{6, x1, x2}
        |0|_A = 15
        isNat_A(x1) = max{0, x1 - 58}
        isNatList_A(x1) = max{5, x1 - 16}
        isNatIList_A(x1) = max{6, x1 - 2}
        and_A(x1,x2) = max{3, x1, x2}
        a__length#_A(x1) = max{44, x1 + 38}
        a__zeros_A = 5
        zeros_A = 4
        a__take_A(x1,x2) = max{21, x1 + 15, x2 + 15}
        a__uTake1_A(x1) = max{20, x1}
        nil_A = 7
        a__uTake2_A(x1,x2,x3,x4) = max{21, x1 + 15, x2 + 15, x3 + 2, x4 + 15}
        a__length_A(x1) = max{53, x1 + 47}
        a__uLength_A(x1,x2) = max{53, x1 + 45, x2 + 47}
  
    precedence:
    
      a__zeros = zeros > tt = s = mark = a__isNat = a__isNatIList = a__isNatList = a__and = isNat = isNatList = and = nil = a__length = a__uLength > take = a__take > a__uTake1 = a__uTake2 > uTake2 > uLength = |0| = isNatIList > a__and# = mark# = a__uLength# = a__uTake2# = uTake1 = a__take# = cons = a__isNatIList# = a__isNat# = length = a__isNatList# = a__length#
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = [1]
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = []
      pi(a__uTake2#) = []
      pi(uTake1) = []
      pi(take) = [1]
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList) = []
      pi(a__and) = []
      pi(|0|) = []
      pi(isNat) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(zeros) = []
      pi(a__take) = [1]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p28

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p18: a__isNat#(s(N)) -> a__isNat#(N)
p19: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p21: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p22: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p23: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatIList#(IL) -> a__isNatList#(IL)
p25: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p26: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p27: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p28: mark#(length(X)) -> mark#(X)
p29: mark#(isNat(X)) -> a__isNat#(X)
p30: mark#(isNatList(X)) -> a__isNatList#(X)
p31: mark#(isNatIList(X)) -> a__isNatIList#(X)
p32: mark#(and(X1,X2)) -> mark#(X2)
p33: mark#(and(X1,X2)) -> mark#(X1)
p34: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p35: a__uLength#(tt(),L) -> a__length#(mark(L))
p36: a__length#(cons(N,L)) -> a__isNatList#(L)
p37: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p38: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p22: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p23: mark#(take(X1,X2)) -> mark#(X1)
p24: mark#(take(X1,X2)) -> mark#(X2)
p25: mark#(uTake1(X)) -> mark#(X)
p26: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p27: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p28: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p29: a__uLength#(tt(),L) -> a__length#(mark(L))
p30: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p31: a__uLength#(tt(),L) -> mark#(L)
p32: mark#(uLength(X1,X2)) -> mark#(X1)
p33: mark#(s(X)) -> mark#(X)
p34: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p35: a__length#(cons(N,L)) -> a__isNatList#(L)
p36: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p37: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p38: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{110, x1 - 61, x2 + 62}
        tt_A = 28
        mark#_A(x1) = max{109, x1 + 62}
        and_A(x1,x2) = max{49, x1 + 3, x2}
        mark_A(x1) = max{36, x1}
        isNatIList_A(x1) = x1 + 83
        a__isNatIList#_A(x1) = x1 + 145
        a__isNatList#_A(x1) = max{122, x1 + 61}
        cons_A(x1,x2) = max{2, x1 - 33, x2}
        a__isNat_A(x1) = max{27, x1 - 38}
        a__isNatList_A(x1) = max{60, x1 - 1}
        a__isNat#_A(x1) = max{2, x1 - 33}
        s_A(x1) = max{108, x1}
        length_A(x1) = max{254, x1 + 217}
        take_A(x1,x2) = max{270, x1 + 233, x2 + 194}
        a__isNatIList_A(x1) = x1 + 83
        isNatList_A(x1) = max{60, x1 - 1}
        isNat_A(x1) = max{1, x1 - 38}
        a__take#_A(x1,x2) = max{x1 + 52, x2 + 196}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 - 1, x2 + 52, x3 + 163, x4 + 195}
        a__and_A(x1,x2) = max{49, x1 + 3, x2}
        uTake1_A(x1) = max{146, x1 + 110}
        uTake2_A(x1,x2,x3,x4) = max{271, x1 + 98, x2 + 233, x3 + 160, x4 + 194}
        uLength_A(x1,x2) = max{254, x1 + 123, x2 + 217}
        a__uLength#_A(x1,x2) = max{122, x2 + 63}
        a__length#_A(x1) = max{122, x1 + 63}
        a__zeros_A = 35
        |0|_A = 67
        zeros_A = 0
        a__take_A(x1,x2) = max{270, x1 + 233, x2 + 194}
        a__uTake1_A(x1) = max{146, x1 + 110}
        nil_A = 139
        a__uTake2_A(x1,x2,x3,x4) = max{271, x1 + 98, x2 + 233, x3 + 160, x4 + 194}
        a__length_A(x1) = max{254, x1 + 217}
        a__uLength_A(x1,x2) = max{254, x1 + 123, x2 + 217}
  
    precedence:
    
      tt = mark = isNatIList = cons = a__isNat = a__isNatList = s = take = a__isNatIList = a__and = uTake1 = uTake2 = a__uLength# = a__length# = a__zeros = a__take = a__uTake1 = a__uTake2 = a__length = a__uLength > a__take# = nil > and > a__and# = mark# = a__isNatIList# = a__isNatList# > a__uTake2# > uLength > a__isNat# = length > isNatList = |0| > isNat = zeros
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = []
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(isNat) = []
      pi(a__take#) = [1, 2]
      pi(a__uTake2#) = [2]
      pi(a__and) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p35

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p22: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p23: mark#(take(X1,X2)) -> mark#(X1)
p24: mark#(take(X1,X2)) -> mark#(X2)
p25: mark#(uTake1(X)) -> mark#(X)
p26: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p27: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p28: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p29: a__uLength#(tt(),L) -> a__length#(mark(L))
p30: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p31: a__uLength#(tt(),L) -> mark#(L)
p32: mark#(uLength(X1,X2)) -> mark#(X1)
p33: mark#(s(X)) -> mark#(X)
p34: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p35: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p36: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p37: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake2(X1,X2,X3,X4)) -> a__uTake2#(mark(X1),X2,X3,X4)
p8: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p9: mark#(uTake1(X)) -> mark#(X)
p10: mark#(take(X1,X2)) -> mark#(X2)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p13: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p18: a__isNat#(s(N)) -> a__isNat#(N)
p19: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p20: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p21: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p22: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p23: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p24: a__isNatIList#(IL) -> a__isNatList#(IL)
p25: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p26: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p27: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p28: mark#(length(X)) -> mark#(X)
p29: mark#(isNat(X)) -> a__isNat#(X)
p30: mark#(isNatList(X)) -> a__isNatList#(X)
p31: mark#(isNatIList(X)) -> a__isNatIList#(X)
p32: mark#(and(X1,X2)) -> mark#(X2)
p33: mark#(and(X1,X2)) -> mark#(X1)
p34: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p35: a__uLength#(tt(),L) -> a__length#(mark(L))
p36: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p37: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{10, x2 - 23}
        tt_A = 53
        mark#_A(x1) = max{9, x1 - 23}
        s_A(x1) = max{76, x1}
        uLength_A(x1,x2) = max{76, x1, x2 + 36}
        a__uLength#_A(x1,x2) = max{53, x1 - 23, x2 + 11}
        mark_A(x1) = max{18, x1}
        uTake2_A(x1,x2,x3,x4) = max{240, x1, x2 + 196, x3 + 100, x4 + 221}
        a__uTake2#_A(x1,x2,x3,x4) = max{x2 + 8, x3 + 10, x4 + 154}
        uTake1_A(x1) = x1
        take_A(x1,x2) = max{239, x1 + 196, x2 + 221}
        a__take#_A(x1,x2) = max{197, x1 + 74, x2 + 154}
        cons_A(x1,x2) = max{9, x1 - 17, x2}
        a__isNatIList#_A(x1) = x1 + 72
        a__isNat#_A(x1) = max{0, x1 - 25}
        length_A(x1) = max{76, x1 + 36}
        a__isNatList#_A(x1) = max{50, x1 + 11}
        a__isNat_A(x1) = max{54, x1 - 2}
        a__isNatIList_A(x1) = x1 + 95
        a__isNatList_A(x1) = max{73, x1 + 34}
        a__and_A(x1,x2) = max{42, x1 + 19, x2}
        isNat_A(x1) = max{54, x1 - 2}
        isNatList_A(x1) = max{73, x1 + 34}
        isNatIList_A(x1) = x1 + 95
        and_A(x1,x2) = max{42, x1 + 19, x2}
        a__length#_A(x1) = max{53, x1 + 11}
        a__zeros_A = 10
        |0|_A = 17
        zeros_A = 9
        a__take_A(x1,x2) = max{239, x1 + 196, x2 + 221}
        a__uTake1_A(x1) = x1
        nil_A = 17
        a__uTake2_A(x1,x2,x3,x4) = max{240, x1, x2 + 196, x3 + 100, x4 + 221}
        a__length_A(x1) = max{76, x1 + 36}
        a__uLength_A(x1,x2) = max{76, x1, x2 + 36}
  
    precedence:
    
      a__and# = mark# = a__uLength# = a__uTake2# = a__take# = a__isNatIList# = a__isNat# = a__isNatList# = a__length# = |0| = zeros > nil > tt = s = uLength = mark = uTake1 = length = a__isNat = a__isNatIList = a__isNatList = a__and = and = a__zeros = a__uTake1 = a__length = a__uLength > uTake2 = cons = a__take = a__uTake2 > take = isNat = isNatList = isNatIList
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = []
      pi(a__uTake2#) = []
      pi(uTake1) = []
      pi(take) = [1]
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList) = []
      pi(a__and) = []
      pi(isNat) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [1]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p8: mark#(uTake1(X)) -> mark#(X)
p9: mark#(take(X1,X2)) -> mark#(X2)
p10: mark#(take(X1,X2)) -> mark#(X1)
p11: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p12: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p14: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p15: a__isNat#(length(L)) -> a__isNatList#(L)
p16: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p17: a__isNat#(s(N)) -> a__isNat#(N)
p18: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p19: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p20: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p21: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p22: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p23: a__isNatIList#(IL) -> a__isNatList#(IL)
p24: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p25: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p26: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p27: mark#(length(X)) -> mark#(X)
p28: mark#(isNat(X)) -> a__isNat#(X)
p29: mark#(isNatList(X)) -> a__isNatList#(X)
p30: mark#(isNatIList(X)) -> a__isNatIList#(X)
p31: mark#(and(X1,X2)) -> mark#(X2)
p32: mark#(and(X1,X2)) -> mark#(X1)
p33: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p34: a__uLength#(tt(),L) -> a__length#(mark(L))
p35: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p36: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p22: a__uTake2#(tt(),M,N,IL) -> mark#(N)
p23: mark#(take(X1,X2)) -> mark#(X1)
p24: mark#(take(X1,X2)) -> mark#(X2)
p25: mark#(uTake1(X)) -> mark#(X)
p26: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p27: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p28: a__uLength#(tt(),L) -> a__length#(mark(L))
p29: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p30: a__uLength#(tt(),L) -> mark#(L)
p31: mark#(uLength(X1,X2)) -> mark#(X1)
p32: mark#(s(X)) -> mark#(X)
p33: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p34: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p35: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p36: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{2, x2 - 12}
        tt_A = 10
        mark#_A(x1) = max{2, x1 - 12}
        and_A(x1,x2) = max{2, x1, x2}
        mark_A(x1) = max{14, x1}
        isNatIList_A(x1) = max{21, x1 + 8}
        a__isNatIList#_A(x1) = max{4, x1 - 4}
        a__isNatList#_A(x1) = max{1, x1 - 12}
        cons_A(x1,x2) = max{14, x1, x2}
        a__isNat_A(x1) = max{11, x1}
        a__isNatList_A(x1) = max{11, x1}
        a__isNat#_A(x1) = max{1, x1 - 12}
        s_A(x1) = max{14, x1}
        length_A(x1) = x1
        take_A(x1,x2) = max{79, x1 + 49, x2 + 64}
        a__isNatIList_A(x1) = max{21, x1 + 8}
        isNatList_A(x1) = max{11, x1}
        isNat_A(x1) = max{1, x1}
        a__take#_A(x1,x2) = max{x1 + 22, x2 + 21}
        a__uTake2#_A(x1,x2,x3,x4) = max{x1 - 7, x2 + 22, x3 - 12, x4 + 20}
        a__and_A(x1,x2) = max{14, x1, x2}
        uTake1_A(x1) = max{63, x1 + 40}
        uTake2_A(x1,x2,x3,x4) = max{79, x1, x2 + 49, x3 + 63, x4 + 64}
        uLength_A(x1,x2) = max{3, x1, x2}
        a__uLength#_A(x1,x2) = max{2, x1 - 27, x2 - 12}
        a__length#_A(x1) = max{1, x1 - 12}
        a__zeros_A = 14
        |0|_A = 11
        zeros_A = 13
        a__take_A(x1,x2) = max{79, x1 + 49, x2 + 64}
        a__uTake1_A(x1) = max{63, x1 + 40}
        nil_A = 49
        a__uTake2_A(x1,x2,x3,x4) = max{79, x1, x2 + 49, x3 + 63, x4 + 64}
        a__length_A(x1) = max{1, x1}
        a__uLength_A(x1,x2) = max{14, x1, x2}
  
    precedence:
    
      and = mark = isNatIList = a__isNat = a__isNatList = s = a__isNatIList = isNatList = isNat = a__and = a__zeros = zeros = a__uTake1 = nil = a__length = a__uLength > a__take > uLength > tt > uTake1 = a__uTake2 > a__and# = mark# = a__isNatIList# = a__isNatList# = cons = a__isNat# = length = take = a__take# = a__uTake2# = uTake2 = a__uLength# = a__length# = |0|
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = []
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(isNat) = []
      pi(a__take#) = [1, 2]
      pi(a__uTake2#) = [2]
      pi(a__and) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p22

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: mark#(isNatList(X)) -> a__isNatList#(X)
p18: mark#(isNat(X)) -> a__isNat#(X)
p19: mark#(length(X)) -> mark#(X)
p20: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p21: a__take#(s(M),cons(N,IL)) -> a__uTake2#(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
p22: mark#(take(X1,X2)) -> mark#(X1)
p23: mark#(take(X1,X2)) -> mark#(X2)
p24: mark#(uTake1(X)) -> mark#(X)
p25: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p26: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p27: a__uLength#(tt(),L) -> a__length#(mark(L))
p28: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p29: a__uLength#(tt(),L) -> mark#(L)
p30: mark#(uLength(X1,X2)) -> mark#(X1)
p31: mark#(s(X)) -> mark#(X)
p32: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p33: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p34: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p35: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__isNat#(N)
p14: a__isNat#(length(L)) -> a__isNatList#(L)
p15: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p16: a__isNat#(s(N)) -> a__isNat#(N)
p17: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p19: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p20: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p21: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p22: a__isNatIList#(IL) -> a__isNatList#(IL)
p23: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p24: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p25: mark#(length(X)) -> mark#(X)
p26: mark#(isNat(X)) -> a__isNat#(X)
p27: mark#(isNatList(X)) -> a__isNatList#(X)
p28: mark#(isNatIList(X)) -> a__isNatIList#(X)
p29: mark#(and(X1,X2)) -> mark#(X2)
p30: mark#(and(X1,X2)) -> mark#(X1)
p31: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p32: a__uLength#(tt(),L) -> a__length#(mark(L))
p33: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p34: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{32, x1 - 25, x2 + 15}
        tt_A = 3
        mark#_A(x1) = max{32, x1 + 15}
        s_A(x1) = max{17, x1}
        uLength_A(x1,x2) = max{29, x1 + 11, x2 + 11}
        a__uLength#_A(x1,x2) = max{32, x2 + 15}
        mark_A(x1) = max{17, x1}
        uTake2_A(x1,x2,x3,x4) = max{16, x1, x2, x3 - 7, x4}
        uTake1_A(x1) = max{21, x1 + 3}
        take_A(x1,x2) = max{4, x1, x2}
        a__take#_A(x1,x2) = max{18, x1 + 15, x2 + 12}
        cons_A(x1,x2) = max{11, x1 - 7, x2}
        a__isNatIList#_A(x1) = max{32, x1 + 12}
        a__isNat#_A(x1) = max{32, x1 + 4}
        length_A(x1) = max{29, x1 + 11}
        a__isNatList#_A(x1) = max{32, x1 + 12}
        a__isNat_A(x1) = max{17, x1 - 10}
        a__isNatIList_A(x1) = max{17, x1 - 3}
        a__isNatList_A(x1) = max{17, x1 - 3}
        a__and_A(x1,x2) = max{17, x1, x2}
        isNat_A(x1) = max{0, x1 - 10}
        isNatList_A(x1) = max{0, x1 - 3}
        isNatIList_A(x1) = max{0, x1 - 3}
        and_A(x1,x2) = max{1, x1, x2}
        a__length#_A(x1) = max{32, x1 + 15}
        a__zeros_A = 16
        |0|_A = 22
        zeros_A = 6
        a__take_A(x1,x2) = max{16, x1, x2}
        a__uTake1_A(x1) = max{21, x1 + 3}
        nil_A = 18
        a__uTake2_A(x1,x2,x3,x4) = max{17, x1, x2, x3 - 7, x4}
        a__length_A(x1) = max{29, x1 + 11}
        a__uLength_A(x1,x2) = max{29, x1 + 11, x2 + 11}
  
    precedence:
    
      zeros > a__and# = mark# = a__uLength# = mark = uTake2 = take = a__take# = cons = a__isNatIList# = a__isNatList# = a__isNat = a__isNatIList = a__isNatList = a__and = isNat = isNatIList = a__length# = |0| = a__take = a__uTake2 > isNatList > a__zeros > tt > uTake1 = a__isNat# = and = a__uTake1 > nil > s = length = a__length = a__uLength > uLength
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = []
      pi(uTake1) = []
      pi(take) = []
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList) = []
      pi(a__and) = []
      pi(isNat) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p13

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNat#(length(L)) -> a__isNatList#(L)
p14: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p15: a__isNat#(s(N)) -> a__isNat#(N)
p16: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p17: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p18: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p19: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p20: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p21: a__isNatIList#(IL) -> a__isNatList#(IL)
p22: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p23: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p24: mark#(length(X)) -> mark#(X)
p25: mark#(isNat(X)) -> a__isNat#(X)
p26: mark#(isNatList(X)) -> a__isNatList#(X)
p27: mark#(isNatIList(X)) -> a__isNatIList#(X)
p28: mark#(and(X1,X2)) -> mark#(X2)
p29: mark#(and(X1,X2)) -> mark#(X1)
p30: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p31: a__uLength#(tt(),L) -> a__length#(mark(L))
p32: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p33: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32, p33}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(isNat(X)) -> a__isNat#(X)
p18: mark#(length(X)) -> mark#(X)
p19: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p20: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p21: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p22: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p23: mark#(take(X1,X2)) -> mark#(X1)
p24: mark#(take(X1,X2)) -> mark#(X2)
p25: mark#(uTake1(X)) -> mark#(X)
p26: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p27: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p28: a__uLength#(tt(),L) -> a__length#(mark(L))
p29: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p30: a__uLength#(tt(),L) -> mark#(L)
p31: mark#(uLength(X1,X2)) -> mark#(X1)
p32: mark#(s(X)) -> mark#(X)
p33: a__length#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{27, x1 - 91, x2 - 74}
        tt_A = 19
        mark#_A(x1) = max{27, x1 - 74}
        and_A(x1,x2) = max{x1, x2}
        mark_A(x1) = max{18, x1}
        isNatIList_A(x1) = x1 + 27
        a__isNatIList#_A(x1) = max{27, x1 - 47}
        a__isNatList#_A(x1) = max{27, x1 - 47}
        cons_A(x1,x2) = max{6, x1 - 12, x2}
        a__isNat_A(x1) = max{4, x1 + 3}
        a__isNatList_A(x1) = x1 + 27
        a__isNat#_A(x1) = max{5, x1 - 165}
        s_A(x1) = max{152, x1}
        length_A(x1) = max{193, x1 + 164}
        take_A(x1,x2) = max{74, x1 + 55, x2 + 55}
        a__isNatIList_A(x1) = x1 + 27
        isNatList_A(x1) = x1 + 27
        isNat_A(x1) = max{4, x1 + 3}
        a__take#_A(x1,x2) = max{0, x1 - 36, x2 - 36}
        a__and_A(x1,x2) = max{17, x1, x2}
        uTake1_A(x1) = max{47, x1 + 28}
        uTake2_A(x1,x2,x3,x4) = max{102, x1 + 23, x2 + 55, x3 + 42, x4 + 55}
        uLength_A(x1,x2) = max{193, x1 + 134, x2 + 164}
        a__uLength#_A(x1,x2) = max{59, x1 + 10, x2 + 40}
        a__length#_A(x1) = max{59, x1 + 40}
        a__zeros_A = 7
        |0|_A = 17
        zeros_A = 0
        a__take_A(x1,x2) = max{74, x1 + 55, x2 + 55}
        a__uTake1_A(x1) = max{47, x1 + 28}
        nil_A = 17
        a__uTake2_A(x1,x2,x3,x4) = max{102, x1 + 23, x2 + 55, x3 + 42, x4 + 55}
        a__length_A(x1) = max{193, x1 + 164}
        a__uLength_A(x1,x2) = max{193, x1 + 134, x2 + 164}
  
    precedence:
    
      a__uLength# = a__length# > and = mark = a__isNatList = a__isNatIList = a__and > a__length > length > zeros > isNatIList > isNatList > uLength = |0| = a__uLength > a__and# = tt = mark# = a__isNatIList# = a__isNatList# = a__isNat = a__isNat# = s = take = isNat = a__take# = a__zeros = a__take = a__uTake1 = nil > cons = uTake2 = a__uTake2 > uTake1
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = []
      pi(a__isNatIList) = []
      pi(isNatList) = [1]
      pi(isNat) = []
      pi(a__take#) = []
      pi(a__and) = []
      pi(uTake1) = [1]
      pi(uTake2) = [3]
      pi(uLength) = [2]
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [3]
      pi(a__length) = []
      pi(a__uLength) = [2]

The next rules are strictly ordered:

  p33

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(isNat(X)) -> a__isNat#(X)
p18: mark#(length(X)) -> mark#(X)
p19: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p20: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p21: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p22: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p23: mark#(take(X1,X2)) -> mark#(X1)
p24: mark#(take(X1,X2)) -> mark#(X2)
p25: mark#(uTake1(X)) -> mark#(X)
p26: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p27: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p28: a__uLength#(tt(),L) -> a__length#(mark(L))
p29: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p30: a__uLength#(tt(),L) -> mark#(L)
p31: mark#(uLength(X1,X2)) -> mark#(X1)
p32: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31, p32}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(IL) -> a__isNatList#(IL)
p15: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p19: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p20: a__isNat#(s(N)) -> a__isNat#(N)
p21: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p22: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p23: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p24: mark#(length(X)) -> mark#(X)
p25: mark#(isNat(X)) -> a__isNat#(X)
p26: mark#(isNatList(X)) -> a__isNatList#(X)
p27: mark#(isNatIList(X)) -> a__isNatIList#(X)
p28: mark#(and(X1,X2)) -> mark#(X2)
p29: mark#(and(X1,X2)) -> mark#(X1)
p30: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p31: a__uLength#(tt(),L) -> a__length#(mark(L))
p32: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 7, x2 + 41}
        tt_A = 26
        mark#_A(x1) = x1 + 41
        s_A(x1) = max{104, x1}
        uLength_A(x1,x2) = max{170, x1 + 78, x2 + 136}
        a__uLength#_A(x1,x2) = max{84, x1 + 14, x2 + 51}
        mark_A(x1) = max{33, x1}
        uTake2_A(x1,x2,x3,x4) = max{232, x1 + 6, x2 + 128, x3 + 92, x4 + 128}
        uTake1_A(x1) = max{38, x1 + 4}
        take_A(x1,x2) = max{162, x1 + 128, x2 + 128}
        a__take#_A(x1,x2) = max{x1 + 6, x2 + 136}
        cons_A(x1,x2) = max{31, x1 - 36, x2}
        a__isNatIList#_A(x1) = x1 + 136
        a__isNat_A(x1) = max{52, x1 - 41}
        a__isNatIList_A(x1) = x1 + 95
        a__isNatList#_A(x1) = x1 + 78
        a__isNat#_A(x1) = max{3, x1}
        length_A(x1) = max{170, x1 + 136}
        a__isNatList_A(x1) = x1 + 37
        a__and_A(x1,x2) = max{68, x1 + 6, x2}
        isNat_A(x1) = max{52, x1 - 41}
        isNatList_A(x1) = x1 + 37
        isNatIList_A(x1) = x1 + 95
        and_A(x1,x2) = max{68, x1 + 6, x2}
        a__length#_A(x1) = max{84, x1 + 51}
        a__zeros_A = 32
        |0|_A = 68
        zeros_A = 25
        a__take_A(x1,x2) = max{162, x1 + 128, x2 + 128}
        a__uTake1_A(x1) = max{38, x1 + 4}
        nil_A = 25
        a__uTake2_A(x1,x2,x3,x4) = max{232, x1 + 6, x2 + 128, x3 + 92, x4 + 128}
        a__length_A(x1) = max{170, x1 + 136}
        a__uLength_A(x1,x2) = max{170, x1 + 78, x2 + 136}
  
    precedence:
    
      a__and# = mark# = a__uLength# = a__take# = a__isNatIList# = a__isNatList# = a__length# > mark = a__isNat = a__isNatIList = a__isNatList = a__and = isNat = isNatList = isNatIList = and = a__zeros = zeros = nil > a__take > a__uTake1 > uTake1 > a__length = a__uLength > length > uLength > s = a__isNat# = |0| = a__uTake2 > tt = cons > uTake2 = take
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = [4]
      pi(uTake1) = [1]
      pi(take) = [2]
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList) = []
      pi(a__and) = []
      pi(isNat) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [1, 2]
      pi(a__uTake1) = [1]
      pi(nil) = []
      pi(a__uTake2) = [1, 4]
      pi(a__length) = []
      pi(a__uLength) = []

The next rules are strictly ordered:

  p25

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(IL) -> a__isNatList#(IL)
p15: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p19: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p20: a__isNat#(s(N)) -> a__isNat#(N)
p21: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p22: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p23: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p24: mark#(length(X)) -> mark#(X)
p25: mark#(isNatList(X)) -> a__isNatList#(X)
p26: mark#(isNatIList(X)) -> a__isNatIList#(X)
p27: mark#(and(X1,X2)) -> mark#(X2)
p28: mark#(and(X1,X2)) -> mark#(X1)
p29: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p30: a__uLength#(tt(),L) -> a__length#(mark(L))
p31: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30, p31}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(length(X)) -> mark#(X)
p18: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p19: a__take#(s(M),cons(N,IL)) -> a__and#(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL)))
p20: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p21: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p22: mark#(take(X1,X2)) -> mark#(X1)
p23: mark#(take(X1,X2)) -> mark#(X2)
p24: mark#(uTake1(X)) -> mark#(X)
p25: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p26: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p27: a__uLength#(tt(),L) -> a__length#(mark(L))
p28: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p29: a__uLength#(tt(),L) -> mark#(L)
p30: mark#(uLength(X1,X2)) -> mark#(X1)
p31: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 - 2, x2}
        tt_A = 24
        mark#_A(x1) = max{21, x1}
        and_A(x1,x2) = max{14, x1, x2}
        mark_A(x1) = max{15, x1}
        isNatIList_A(x1) = max{20, x1 + 15}
        a__isNatIList#_A(x1) = max{20, x1 + 15}
        a__isNatList#_A(x1) = max{19, x1 + 12}
        cons_A(x1,x2) = max{1, x1, x2}
        a__isNat_A(x1) = max{19, x1 + 11}
        a__isNatList_A(x1) = max{19, x1 + 12}
        a__isNat#_A(x1) = max{19, x1 + 12}
        s_A(x1) = x1
        length_A(x1) = max{66, x1 + 50}
        take_A(x1,x2) = max{59, x1 + 44, x2 + 43}
        a__isNatIList_A(x1) = max{20, x1 + 15}
        isNatList_A(x1) = max{19, x1 + 12}
        a__take#_A(x1,x2) = max{x1 + 21, x2 + 21}
        a__and_A(x1,x2) = max{14, x1, x2}
        uTake1_A(x1) = max{37, x1 + 22}
        uTake2_A(x1,x2,x3,x4) = max{59, x1 + 22, x2 + 44, x3 + 36, x4 + 43}
        uLength_A(x1,x2) = max{66, x1 + 38, x2 + 50}
        a__uLength#_A(x1,x2) = max{37, x1 + 2, x2 + 22}
        a__length#_A(x1) = max{37, x1 + 22}
        a__zeros_A = 14
        |0|_A = 13
        zeros_A = 13
        a__take_A(x1,x2) = max{59, x1 + 44, x2 + 43}
        a__uTake1_A(x1) = max{37, x1 + 22}
        nil_A = 38
        a__uTake2_A(x1,x2,x3,x4) = max{59, x1 + 22, x2 + 44, x3 + 36, x4 + 43}
        a__length_A(x1) = max{66, x1 + 50}
        a__uLength_A(x1,x2) = max{66, x1 + 38, x2 + 50}
        isNat_A(x1) = max{19, x1 + 11}
  
    precedence:
    
      and = mark = a__isNatList = s = a__isNatIList = a__and = a__length = a__uLength > a__zeros > take = uTake2 = a__take = a__uTake2 > uTake1 = a__uTake1 > a__isNat = isNat > zeros > |0| > tt > nil > a__and# = mark# = isNatIList = a__isNatIList# = a__isNatList# = cons = length = isNatList = a__take# = uLength = a__uLength# = a__length# > a__isNat#
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = [1]
      pi(a__isNatList) = []
      pi(a__isNat#) = [1]
      pi(s) = []
      pi(length) = [1]
      pi(take) = []
      pi(a__isNatIList) = []
      pi(isNatList) = [1]
      pi(a__take#) = []
      pi(a__and) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p19

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(length(X)) -> mark#(X)
p18: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p19: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p20: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p21: mark#(take(X1,X2)) -> mark#(X1)
p22: mark#(take(X1,X2)) -> mark#(X2)
p23: mark#(uTake1(X)) -> mark#(X)
p24: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p25: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p26: a__uLength#(tt(),L) -> a__length#(mark(L))
p27: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p28: a__uLength#(tt(),L) -> mark#(L)
p29: mark#(uLength(X1,X2)) -> mark#(X1)
p30: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29, p30}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(IL) -> a__isNatList#(IL)
p15: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p19: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p20: a__isNat#(s(N)) -> a__isNat#(N)
p21: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p22: a__take#(s(M),cons(N,IL)) -> a__isNat#(M)
p23: mark#(length(X)) -> mark#(X)
p24: mark#(isNatList(X)) -> a__isNatList#(X)
p25: mark#(isNatIList(X)) -> a__isNatIList#(X)
p26: mark#(and(X1,X2)) -> mark#(X2)
p27: mark#(and(X1,X2)) -> mark#(X1)
p28: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p29: a__uLength#(tt(),L) -> a__length#(mark(L))
p30: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 35, x2 + 35}
        tt_A = 4
        mark#_A(x1) = x1 + 35
        s_A(x1) = max{51, x1}
        uLength_A(x1,x2) = max{51, x1 + 4, x2}
        a__uLength#_A(x1,x2) = max{54, x1 - 16, x2 + 35}
        mark_A(x1) = max{9, x1}
        uTake2_A(x1,x2,x3,x4) = max{63, x1 + 4, x2 + 7, x3 + 8, x4 + 29}
        uTake1_A(x1) = max{19, x1 + 10}
        take_A(x1,x2) = max{63, x1 + 7, x2 + 29}
        a__take#_A(x1,x2) = max{x1 + 42, x2 + 53}
        cons_A(x1,x2) = max{18, x1 + 8, x2}
        a__isNatIList#_A(x1) = x1 + 53
        a__isNat_A(x1) = max{9, x1 + 3}
        a__isNatIList_A(x1) = x1 + 18
        a__isNatList#_A(x1) = max{52, x1 + 31}
        a__isNat#_A(x1) = x1 + 38
        length_A(x1) = max{51, x1}
        a__isNatList_A(x1) = max{17, x1 - 4}
        isNatList_A(x1) = max{17, x1 - 4}
        isNatIList_A(x1) = x1 + 18
        and_A(x1,x2) = max{15, x1, x2}
        a__length#_A(x1) = max{54, x1 + 35}
        a__and_A(x1,x2) = max{15, x1, x2}
        a__zeros_A = 22
        |0|_A = 13
        zeros_A = 22
        a__take_A(x1,x2) = max{63, x1 + 7, x2 + 29}
        a__uTake1_A(x1) = max{19, x1 + 10}
        nil_A = 13
        a__uTake2_A(x1,x2,x3,x4) = max{63, x1 + 4, x2 + 7, x3 + 8, x4 + 29}
        a__length_A(x1) = max{51, x1}
        a__uLength_A(x1,x2) = max{51, x1 + 4, x2}
        isNat_A(x1) = max{9, x1 + 3}
  
    precedence:
    
      mark = a__isNat = a__isNatIList = a__isNatList = isNatList = isNatIList = a__and = a__zeros = a__take = a__uTake2 = isNat > zeros > take > and > tt > s = uTake1 = cons = a__uTake1 = a__length = a__uLength > uLength > a__and# = mark# = a__uLength# = a__take# = a__isNatIList# = a__isNatList# = a__isNat# = length = a__length# > nil > uTake2 > |0|
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = []
      pi(uTake1) = []
      pi(take) = [1, 2]
      pi(a__take#) = []
      pi(cons) = []
      pi(a__isNatIList#) = []
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(a__isNatList#) = []
      pi(a__isNat#) = []
      pi(length) = []
      pi(a__isNatList) = []
      pi(isNatList) = []
      pi(isNatIList) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p22

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p11: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(IL) -> a__isNatList#(IL)
p15: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p16: a__isNat#(length(L)) -> a__isNatList#(L)
p17: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p19: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p20: a__isNat#(s(N)) -> a__isNat#(N)
p21: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p22: mark#(length(X)) -> mark#(X)
p23: mark#(isNatList(X)) -> a__isNatList#(X)
p24: mark#(isNatIList(X)) -> a__isNatIList#(X)
p25: mark#(and(X1,X2)) -> mark#(X2)
p26: mark#(and(X1,X2)) -> mark#(X1)
p27: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p28: a__uLength#(tt(),L) -> a__length#(mark(L))
p29: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p27, p28, p29}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(length(X)) -> mark#(X)
p18: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p19: a__take#(s(M),cons(N,IL)) -> a__isNatIList#(IL)
p20: mark#(take(X1,X2)) -> mark#(X1)
p21: mark#(take(X1,X2)) -> mark#(X2)
p22: mark#(uTake1(X)) -> mark#(X)
p23: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p24: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p25: a__uLength#(tt(),L) -> a__length#(mark(L))
p26: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p27: a__uLength#(tt(),L) -> mark#(L)
p28: mark#(uLength(X1,X2)) -> mark#(X1)
p29: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{23, x1 - 34, x2 + 13}
        tt_A = 163
        mark#_A(x1) = max{22, x1 + 13}
        and_A(x1,x2) = max{45, x1 + 11, x2}
        mark_A(x1) = max{33, x1}
        isNatIList_A(x1) = x1 + 69
        a__isNatIList#_A(x1) = x1 + 82
        a__isNatList#_A(x1) = max{21, x1}
        cons_A(x1,x2) = max{67, x1 + 31, x2}
        a__isNat_A(x1) = max{6, x1 + 1}
        a__isNatList_A(x1) = max{7, x1 - 13}
        a__isNat#_A(x1) = x1 + 30
        s_A(x1) = x1
        length_A(x1) = max{230, x1 + 197}
        take_A(x1,x2) = max{184, x1 + 151, x2 + 117}
        a__isNatIList_A(x1) = x1 + 69
        isNatList_A(x1) = max{7, x1 - 13}
        a__take#_A(x1,x2) = max{x1 + 83, x2 + 83}
        uTake1_A(x1) = max{183, x1}
        uTake2_A(x1,x2,x3,x4) = max{184, x1 + 21, x2 + 151, x3 + 65, x4 + 117}
        uLength_A(x1,x2) = max{x1 + 67, x2 + 197}
        a__uLength#_A(x1,x2) = max{66, x1 - 15, x2 + 34}
        a__length#_A(x1) = x1 + 34
        a__and_A(x1,x2) = max{45, x1 + 11, x2}
        a__zeros_A = 196
        |0|_A = 164
        zeros_A = 196
        a__take_A(x1,x2) = max{184, x1 + 151, x2 + 117}
        a__uTake1_A(x1) = max{183, x1}
        nil_A = 183
        a__uTake2_A(x1,x2,x3,x4) = max{184, x1 + 21, x2 + 151, x3 + 65, x4 + 117}
        a__length_A(x1) = max{230, x1 + 197}
        a__uLength_A(x1,x2) = max{x1 + 67, x2 + 197}
        isNat_A(x1) = max{6, x1 + 1}
  
    precedence:
    
      and = mark = isNatIList = a__isNatList = s = length = a__isNatIList = isNatList = uLength = a__and = a__zeros = a__length = a__uLength > a__take > a__uTake2 > take = uTake2 > |0| > uTake1 = a__uLength# = a__length# = a__uTake1 > a__isNat = isNat > cons > a__and# = mark# = a__isNatIList# = a__isNatList# > a__take# = zeros > tt = a__isNat# > nil
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = [1]
      pi(a__isNatList) = []
      pi(a__isNat#) = [1]
      pi(s) = []
      pi(length) = []
      pi(take) = [1]
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(a__take#) = [2]
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(a__length#) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [1, 2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [2, 3]
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = [1]

The next rules are strictly ordered:

  p19

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(length(X)) -> mark#(X)
p18: mark#(take(X1,X2)) -> a__take#(mark(X1),mark(X2))
p19: mark#(take(X1,X2)) -> mark#(X1)
p20: mark#(take(X1,X2)) -> mark#(X2)
p21: mark#(uTake1(X)) -> mark#(X)
p22: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p23: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p24: a__uLength#(tt(),L) -> a__length#(mark(L))
p25: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p26: a__uLength#(tt(),L) -> mark#(L)
p27: mark#(uLength(X1,X2)) -> mark#(X1)
p28: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28}


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> a__uLength#(mark(X1),X2)
p5: a__uLength#(tt(),L) -> mark#(L)
p6: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p7: mark#(uTake1(X)) -> mark#(X)
p8: mark#(take(X1,X2)) -> mark#(X2)
p9: mark#(take(X1,X2)) -> mark#(X1)
p10: mark#(length(X)) -> mark#(X)
p11: mark#(isNatList(X)) -> a__isNatList#(X)
p12: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p13: a__isNat#(length(L)) -> a__isNatList#(L)
p14: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p16: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p17: a__isNat#(s(N)) -> a__isNat#(N)
p18: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p19: mark#(isNatIList(X)) -> a__isNatIList#(X)
p20: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p21: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p22: a__isNatIList#(IL) -> a__isNatList#(IL)
p23: mark#(and(X1,X2)) -> mark#(X2)
p24: mark#(and(X1,X2)) -> mark#(X1)
p25: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p26: a__uLength#(tt(),L) -> a__length#(mark(L))
p27: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{1, x1 - 80, x2 - 12}
        tt_A = 83
        mark#_A(x1) = max{2, x1 - 12}
        s_A(x1) = max{84, x1}
        uLength_A(x1,x2) = max{215, x1 + 61, x2 + 166}
        a__uLength#_A(x1,x2) = max{42, x1 - 45, x2 - 11}
        mark_A(x1) = max{48, x1}
        uTake2_A(x1,x2,x3,x4) = max{150, x1 + 1, x2 + 100, x3 + 83, x4 + 100}
        uTake1_A(x1) = max{149, x1 + 3}
        take_A(x1,x2) = max{149, x1 + 100, x2 + 100}
        length_A(x1) = max{215, x1 + 166}
        isNatList_A(x1) = max{87, x1 + 34}
        a__isNatList#_A(x1) = max{75, x1 + 22}
        a__isNat#_A(x1) = x1 + 1
        a__isNat_A(x1) = max{84, x1 - 1}
        a__isNatIList_A(x1) = x1 + 97
        cons_A(x1,x2) = max{43, x1 - 17, x2}
        a__isNatList_A(x1) = max{87, x1 + 34}
        isNatIList_A(x1) = x1 + 97
        a__isNatIList#_A(x1) = x1 + 85
        and_A(x1,x2) = max{78, x1 + 2, x2}
        a__length#_A(x1) = max{42, x1 - 11}
        a__and_A(x1,x2) = max{78, x1 + 2, x2}
        a__zeros_A = 47
        |0|_A = 64
        zeros_A = 46
        a__take_A(x1,x2) = max{149, x1 + 100, x2 + 100}
        a__uTake1_A(x1) = max{149, x1 + 3}
        nil_A = 87
        a__uTake2_A(x1,x2,x3,x4) = max{150, x1 + 1, x2 + 100, x3 + 83, x4 + 100}
        a__length_A(x1) = max{215, x1 + 166}
        a__uLength_A(x1,x2) = max{215, x1 + 61, x2 + 166}
        isNat_A(x1) = max{84, x1 - 1}
  
    precedence:
    
      s = mark = isNatList = a__isNat = a__isNatIList = a__isNatList = isNatIList = and = a__and = a__length = a__uLength > a__take > uTake1 = |0| = a__uTake1 > uTake2 = a__uTake2 > cons = a__zeros > a__and# = mark# = uLength = a__uLength# = take = a__isNatList# = a__isNatIList# = a__length# = isNat > tt = zeros > a__isNat# > length > nil
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(a__uLength#) = []
      pi(mark) = []
      pi(uTake2) = [3]
      pi(uTake1) = []
      pi(take) = [2]
      pi(length) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(a__isNat#) = [1]
      pi(a__isNat) = []
      pi(a__isNatIList) = []
      pi(cons) = []
      pi(a__isNatList) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(and) = []
      pi(a__length#) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [3]
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: a__uLength#(tt(),L) -> mark#(L)
p5: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p6: mark#(uTake1(X)) -> mark#(X)
p7: mark#(take(X1,X2)) -> mark#(X2)
p8: mark#(take(X1,X2)) -> mark#(X1)
p9: mark#(length(X)) -> mark#(X)
p10: mark#(isNatList(X)) -> a__isNatList#(X)
p11: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p12: a__isNat#(length(L)) -> a__isNatList#(L)
p13: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p15: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p16: a__isNat#(s(N)) -> a__isNat#(N)
p17: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p18: mark#(isNatIList(X)) -> a__isNatIList#(X)
p19: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p20: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p21: a__isNatIList#(IL) -> a__isNatList#(IL)
p22: mark#(and(X1,X2)) -> mark#(X2)
p23: mark#(and(X1,X2)) -> mark#(X1)
p24: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p25: a__uLength#(tt(),L) -> a__length#(mark(L))
p26: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__length#(cons(N,L)) -> a__uLength#(a__and(a__isNat(N),a__isNatList(L)),L)
p2: a__uLength#(tt(),L) -> a__length#(mark(L))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__length#_A(x1) = max{9, x1 + 4}
        cons_A(x1,x2) = x2 + 16
        a__uLength#_A(x1,x2) = max{x1 - 45, x2 + 10}
        a__and_A(x1,x2) = max{61, x2 + 8}
        a__isNat_A(x1) = x1 + 170
        a__isNatList_A(x1) = x1 + 53
        tt_A = 128
        mark_A(x1) = max{24, x1}
        a__isNatIList_A(x1) = max{127, x1 + 123}
        zeros_A = 6
        a__zeros_A = 23
        |0|_A = 11
        a__take_A(x1,x2) = max{127, x1 + 103, x2 + 78}
        a__uTake1_A(x1) = max{77, x1 - 45}
        nil_A = 76
        s_A(x1) = max{218, x1 + 16}
        a__uTake2_A(x1,x2,x3,x4) = max{144, x2 + 119, x4 + 94}
        take_A(x1,x2) = max{127, x1 + 103, x2 + 78}
        a__length_A(x1) = max{201, x1 + 160}
        a__uLength_A(x1,x2) = max{201, x1 + 90, x2 + 176}
        isNatIList_A(x1) = max{127, x1 + 123}
        length_A(x1) = max{201, x1 + 160}
        uTake1_A(x1) = max{77, x1 - 45}
        uTake2_A(x1,x2,x3,x4) = max{144, x2 + 119, x4 + 94}
        uLength_A(x1,x2) = max{201, x1 + 90, x2 + 176}
        and_A(x1,x2) = max{61, x2 + 8}
        isNatList_A(x1) = x1 + 53
        isNat_A(x1) = x1 + 170
  
    precedence:
    
      |0| > cons = mark = a__zeros = a__take = a__uTake1 = nil = a__uTake2 = take = uTake2 > a__isNatIList = isNatIList > a__isNat = tt = isNat > a__isNatList > zeros = a__length > uTake1 > s = a__uLength > length > a__and = uLength = and > a__uLength# > a__length# > isNatList
    
    partial status:
  
      pi(a__length#) = [1]
      pi(cons) = []
      pi(a__uLength#) = []
      pi(a__and) = []
      pi(a__isNat) = [1]
      pi(a__isNatList) = [1]
      pi(tt) = []
      pi(mark) = []
      pi(a__isNatIList) = [1]
      pi(zeros) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(s) = []
      pi(a__uTake2) = []
      pi(take) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNatIList) = [1]
      pi(length) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(and) = []
      pi(isNatList) = [1]
      pi(isNat) = []

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: a__uLength#(tt(),L) -> a__length#(mark(L))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  (no SCCs)

-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p14: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: mark#(isNatList(X)) -> a__isNatList#(X)
p17: mark#(length(X)) -> mark#(X)
p18: mark#(take(X1,X2)) -> mark#(X1)
p19: mark#(take(X1,X2)) -> mark#(X2)
p20: mark#(uTake1(X)) -> mark#(X)
p21: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p22: mark#(uLength(X1,X2)) -> mark#(X1)
p23: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 - 3, x2 + 2}
        tt_A = 10
        mark#_A(x1) = max{7, x1 + 2}
        and_A(x1,x2) = max{3, x1, x2}
        mark_A(x1) = x1
        isNatIList_A(x1) = max{20, x1 + 7}
        a__isNatIList#_A(x1) = x1 + 9
        a__isNatList#_A(x1) = max{7, x1 + 6}
        cons_A(x1,x2) = max{x1 + 13, x2}
        a__isNat_A(x1) = x1 + 2
        a__isNatList_A(x1) = x1 + 4
        a__isNat#_A(x1) = max{19, x1 - 1}
        s_A(x1) = max{21, x1}
        length_A(x1) = x1 + 20
        take_A(x1,x2) = max{x1 + 25, x2 + 23}
        a__isNatIList_A(x1) = max{20, x1 + 7}
        isNatList_A(x1) = x1 + 4
        uTake1_A(x1) = x1 + 4
        uTake2_A(x1,x2,x3,x4) = max{x1, x2 + 25, x3 + 36, x4 + 23}
        uLength_A(x1,x2) = max{32, x1 + 15, x2 + 20}
        a__and_A(x1,x2) = max{3, x1, x2}
        a__zeros_A = 23
        |0|_A = 9
        zeros_A = 23
        a__take_A(x1,x2) = max{x1 + 25, x2 + 23}
        a__uTake1_A(x1) = x1 + 4
        nil_A = 11
        a__uTake2_A(x1,x2,x3,x4) = max{x1, x2 + 25, x3 + 36, x4 + 23}
        a__length_A(x1) = x1 + 20
        a__uLength_A(x1,x2) = max{32, x1 + 15, x2 + 20}
        isNat_A(x1) = x1 + 2
  
    precedence:
    
      mark = a__isNatList = a__isNatIList = a__and = nil > a__and# = mark# = a__isNatIList# = a__isNatList# > tt = isNatIList = a__isNat = s = length = a__zeros = |0| = zeros = a__length = a__uLength = isNat > a__uTake1 > uTake1 > a__isNat# = isNatList = a__take > a__uTake2 > take > and = cons = uLength > uTake2
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = [1]
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = [1]
      pi(take) = [2]
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [2]
      pi(a__uTake1) = [1]
      pi(nil) = []
      pi(a__uTake2) = [4]
      pi(a__length) = [1]
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p12

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: mark#(isNatList(X)) -> a__isNatList#(X)
p16: mark#(length(X)) -> mark#(X)
p17: mark#(take(X1,X2)) -> mark#(X1)
p18: mark#(take(X1,X2)) -> mark#(X2)
p19: mark#(uTake1(X)) -> mark#(X)
p20: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p21: mark#(uLength(X1,X2)) -> mark#(X1)
p22: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X2)
p7: mark#(take(X1,X2)) -> mark#(X1)
p8: mark#(length(X)) -> mark#(X)
p9: mark#(isNatList(X)) -> a__isNatList#(X)
p10: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p11: a__isNat#(length(L)) -> a__isNatList#(L)
p12: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p13: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p14: a__isNat#(s(N)) -> a__isNat#(N)
p15: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p16: mark#(isNatIList(X)) -> a__isNatIList#(X)
p17: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p18: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p19: a__isNatIList#(IL) -> a__isNatList#(IL)
p20: mark#(and(X1,X2)) -> mark#(X2)
p21: mark#(and(X1,X2)) -> mark#(X1)
p22: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 1, x2 + 24}
        tt_A = 8
        mark#_A(x1) = x1 + 24
        s_A(x1) = max{4, x1}
        uLength_A(x1,x2) = max{1, x1, x2}
        uTake2_A(x1,x2,x3,x4) = max{33, x1 + 6, x2 + 15, x4 + 23}
        uTake1_A(x1) = max{17, x1 + 7}
        take_A(x1,x2) = max{33, x1 + 15, x2 + 23}
        length_A(x1) = max{7, x1}
        isNatList_A(x1) = 8
        a__isNatList#_A(x1) = 32
        a__isNat#_A(x1) = 32
        cons_A(x1,x2) = max{1, x2}
        a__isNat_A(x1) = 8
        a__isNatList_A(x1) = 8
        isNatIList_A(x1) = 8
        a__isNatIList#_A(x1) = 32
        a__isNatIList_A(x1) = 8
        and_A(x1,x2) = max{8, x1, x2}
        mark_A(x1) = max{8, x1}
        a__and_A(x1,x2) = max{8, x1, x2}
        a__zeros_A = 2
        |0|_A = 3
        zeros_A = 0
        a__take_A(x1,x2) = max{33, x1 + 15, x2 + 23}
        a__uTake1_A(x1) = max{17, x1 + 7}
        nil_A = 16
        a__uTake2_A(x1,x2,x3,x4) = max{33, x1 + 6, x2 + 15, x4 + 23}
        a__length_A(x1) = max{8, x1}
        a__uLength_A(x1,x2) = max{3, x1, x2}
        isNat_A(x1) = 8
  
    precedence:
    
      a__and# = tt = mark# = s = uLength = uTake2 = uTake1 = take = length = isNatList = a__isNatList# = a__isNat# = cons = a__isNat = a__isNatList = isNatIList = a__isNatIList# = a__isNatIList = and = mark = a__and = a__zeros = |0| = zeros = a__take = a__uTake1 = nil = a__uTake2 = a__length = a__uLength = isNat
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(uTake2) = []
      pi(uTake1) = []
      pi(take) = []
      pi(length) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(a__isNat#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatIList) = []
      pi(and) = []
      pi(mark) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(length(X)) -> mark#(X)
p8: mark#(isNatList(X)) -> a__isNatList#(X)
p9: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p13: a__isNat#(s(N)) -> a__isNat#(N)
p14: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p15: mark#(isNatIList(X)) -> a__isNatIList#(X)
p16: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p17: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p18: a__isNatIList#(IL) -> a__isNatList#(IL)
p19: mark#(and(X1,X2)) -> mark#(X2)
p20: mark#(and(X1,X2)) -> mark#(X1)
p21: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNat#(N)
p9: a__isNat#(s(N)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: mark#(isNatList(X)) -> a__isNatList#(X)
p16: mark#(length(X)) -> mark#(X)
p17: mark#(take(X1,X2)) -> mark#(X1)
p18: mark#(uTake1(X)) -> mark#(X)
p19: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p20: mark#(uLength(X1,X2)) -> mark#(X1)
p21: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{3, x1 - 11, x2 - 28}
        tt_A = 17
        mark#_A(x1) = max{5, x1 - 28}
        and_A(x1,x2) = max{x1 + 17, x2}
        mark_A(x1) = x1
        isNatIList_A(x1) = max{24, x1 + 18}
        a__isNatIList#_A(x1) = max{4, x1 - 10}
        a__isNatList#_A(x1) = max{4, x1 - 10}
        cons_A(x1,x2) = max{x1 + 12, x2}
        a__isNat_A(x1) = x1 + 8
        a__isNatList_A(x1) = x1 + 18
        a__isNat#_A(x1) = max{1, x1 - 12}
        s_A(x1) = max{12, x1}
        length_A(x1) = x1 + 33
        take_A(x1,x2) = max{33, x1 + 32, x2 + 32}
        a__isNatIList_A(x1) = max{24, x1 + 18}
        isNatList_A(x1) = x1 + 18
        uTake1_A(x1) = x1 + 7
        uTake2_A(x1,x2,x3,x4) = max{x1 + 7, x2 + 32, x3 + 33, x4 + 32}
        uLength_A(x1,x2) = max{x1 + 10, x2 + 33}
        a__and_A(x1,x2) = max{x1 + 17, x2}
        a__zeros_A = 30
        |0|_A = 18
        zeros_A = 30
        a__take_A(x1,x2) = max{33, x1 + 32, x2 + 32}
        a__uTake1_A(x1) = x1 + 7
        nil_A = 18
        a__uTake2_A(x1,x2,x3,x4) = max{x1 + 7, x2 + 32, x3 + 33, x4 + 32}
        a__length_A(x1) = x1 + 33
        a__uLength_A(x1,x2) = max{x1 + 10, x2 + 33}
        isNat_A(x1) = x1 + 8
  
    precedence:
    
      isNatIList = a__isNatIList > a__isNatList = isNatList > a__and# = mark# = and = mark = a__isNatIList# = a__isNatList# = uTake2 = a__and = a__zeros = a__take = nil = a__uTake2 > take > tt = cons = a__isNat > isNat > zeros > a__isNat# = s = length = uLength = |0| = a__length = a__uLength > uTake1 = a__uTake1
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = [2]
      pi(mark) = [1]
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = [2]
      pi(a__isNat) = []
      pi(a__isNatList) = [1]
      pi(a__isNat#) = []
      pi(s) = []
      pi(length) = []
      pi(take) = []
      pi(a__isNatIList) = [1]
      pi(isNatList) = [1]
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(a__and) = [2]
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p8

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNat#(s(N)) -> a__isNat#(N)
p9: a__isNat#(length(L)) -> a__isNatList#(L)
p10: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p11: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p12: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p14: mark#(isNatList(X)) -> a__isNatList#(X)
p15: mark#(length(X)) -> mark#(X)
p16: mark#(take(X1,X2)) -> mark#(X1)
p17: mark#(uTake1(X)) -> mark#(X)
p18: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p19: mark#(uLength(X1,X2)) -> mark#(X1)
p20: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(length(X)) -> mark#(X)
p8: mark#(isNatList(X)) -> a__isNatList#(X)
p9: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p10: a__isNat#(length(L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p12: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p13: a__isNat#(s(N)) -> a__isNat#(N)
p14: mark#(isNatIList(X)) -> a__isNatIList#(X)
p15: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p16: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p17: a__isNatIList#(IL) -> a__isNatList#(IL)
p18: mark#(and(X1,X2)) -> mark#(X2)
p19: mark#(and(X1,X2)) -> mark#(X1)
p20: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 48, x2 + 52}
        tt_A = 0
        mark#_A(x1) = x1 + 52
        s_A(x1) = max{2, x1}
        uLength_A(x1,x2) = max{62, x1, x2 + 55}
        uTake2_A(x1,x2,x3,x4) = max{x1 + 4, x2 + 17, x3 + 34, x4 + 25}
        uTake1_A(x1) = max{24, x1 + 5}
        take_A(x1,x2) = max{31, x1 + 17, x2 + 25}
        length_A(x1) = max{61, x1 + 55}
        isNatList_A(x1) = max{8, x1 - 43}
        a__isNatList#_A(x1) = max{60, x1 + 9}
        a__isNat#_A(x1) = x1 + 17
        cons_A(x1,x2) = max{16, x1 + 9, x2}
        a__isNat_A(x1) = max{1, x1 - 36}
        a__isNatList_A(x1) = max{8, x1 - 43}
        isNatIList_A(x1) = max{8, x1 - 18}
        a__isNatIList#_A(x1) = max{60, x1 + 34}
        a__isNatIList_A(x1) = max{8, x1 - 18}
        and_A(x1,x2) = max{8, x1 + 1, x2}
        mark_A(x1) = max{6, x1}
        a__and_A(x1,x2) = max{8, x1 + 1, x2}
        a__zeros_A = 17
        |0|_A = 7
        zeros_A = 17
        a__take_A(x1,x2) = max{31, x1 + 17, x2 + 25}
        a__uTake1_A(x1) = max{24, x1 + 5}
        nil_A = 23
        a__uTake2_A(x1,x2,x3,x4) = max{x1 + 4, x2 + 17, x3 + 34, x4 + 25}
        a__length_A(x1) = max{61, x1 + 55}
        a__uLength_A(x1,x2) = max{62, x1, x2 + 55}
        isNat_A(x1) = max{1, x1 - 36}
  
    precedence:
    
      take = length = isNatList = a__isNat = a__isNatList = a__isNatIList = mark = a__and = a__zeros = |0| = zeros = a__take = a__length > a__and# = mark# = s = a__isNatList# = a__isNatIList# = a__uLength > a__isNat# > tt > uLength = isNat > uTake1 = a__uTake1 > cons = and = a__uTake2 > uTake2 > isNatIList = nil
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(uTake2) = [1]
      pi(uTake1) = []
      pi(take) = []
      pi(length) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(a__isNat#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatIList) = []
      pi(and) = [1]
      pi(mark) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [1, 4]
      pi(a__length) = []
      pi(a__uLength) = [2]
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(length(X)) -> mark#(X)
p8: mark#(isNatList(X)) -> a__isNatList#(X)
p9: a__isNatList#(take(N,IL)) -> a__isNat#(N)
p10: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p11: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p12: a__isNat#(s(N)) -> a__isNat#(N)
p13: mark#(isNatIList(X)) -> a__isNatIList#(X)
p14: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p15: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p16: a__isNatIList#(IL) -> a__isNatList#(IL)
p17: mark#(and(X1,X2)) -> mark#(X2)
p18: mark#(and(X1,X2)) -> mark#(X1)
p19: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(IL) -> a__isNatList#(IL)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p9: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p10: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p11: mark#(isNatList(X)) -> a__isNatList#(X)
p12: mark#(length(X)) -> mark#(X)
p13: mark#(take(X1,X2)) -> mark#(X1)
p14: mark#(uTake1(X)) -> mark#(X)
p15: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p16: mark#(uLength(X1,X2)) -> mark#(X1)
p17: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{14, x1 + 4, x2 + 11}
        tt_A = 13
        mark#_A(x1) = max{16, x1 + 11}
        and_A(x1,x2) = max{15, x1, x2}
        mark_A(x1) = max{15, x1}
        isNatIList_A(x1) = x1 + 16
        a__isNatIList#_A(x1) = x1 + 27
        a__isNatList#_A(x1) = max{26, x1 + 5}
        cons_A(x1,x2) = max{15, x1, x2}
        a__isNat_A(x1) = max{15, x1 - 6}
        a__isNatList_A(x1) = max{15, x1 - 6}
        a__isNatIList_A(x1) = x1 + 16
        isNatList_A(x1) = max{15, x1 - 6}
        length_A(x1) = max{14, x1}
        take_A(x1,x2) = max{38, x1, x2 + 22}
        uTake1_A(x1) = max{21, x1 + 6}
        uTake2_A(x1,x2,x3,x4) = max{38, x1, x2, x3 + 22, x4 + 22}
        uLength_A(x1,x2) = max{14, x1, x2}
        s_A(x1) = x1
        a__and_A(x1,x2) = max{15, x1, x2}
        a__zeros_A = 15
        |0|_A = 15
        zeros_A = 14
        a__take_A(x1,x2) = max{38, x1, x2 + 22}
        a__uTake1_A(x1) = max{21, x1 + 6}
        nil_A = 20
        a__uTake2_A(x1,x2,x3,x4) = max{38, x1, x2, x3 + 22, x4 + 22}
        a__length_A(x1) = max{14, x1}
        a__uLength_A(x1,x2) = max{15, x1, x2}
        isNat_A(x1) = max{15, x1 - 6}
  
    precedence:
    
      tt = mark = cons = a__isNat = a__isNatList = a__isNatIList = length = take = uTake2 = s = a__and = a__zeros = |0| = zeros = a__take = nil = a__uTake2 = a__length = a__uLength = isNat > uLength = a__uTake1 > uTake1 > a__and# = mark# = and = isNatIList = a__isNatIList# = a__isNatList# = isNatList
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = []
      pi(mark) = []
      pi(isNatIList) = []
      pi(a__isNatIList#) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(a__isNatIList) = []
      pi(isNatList) = []
      pi(length) = []
      pi(take) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(uLength) = []
      pi(s) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p7: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p8: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p9: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p10: mark#(isNatList(X)) -> a__isNatList#(X)
p11: mark#(length(X)) -> mark#(X)
p12: mark#(take(X1,X2)) -> mark#(X1)
p13: mark#(uTake1(X)) -> mark#(X)
p14: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p15: mark#(uLength(X1,X2)) -> mark#(X1)
p16: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(length(X)) -> mark#(X)
p8: mark#(isNatList(X)) -> a__isNatList#(X)
p9: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p10: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p11: mark#(isNatIList(X)) -> a__isNatIList#(X)
p12: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p13: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p14: mark#(and(X1,X2)) -> mark#(X2)
p15: mark#(and(X1,X2)) -> mark#(X1)
p16: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{44, x2 + 14}
        tt_A = 8
        mark#_A(x1) = max{44, x1 + 14}
        s_A(x1) = max{30, x1}
        uLength_A(x1,x2) = max{x1 + 2, x2 + 40}
        uTake2_A(x1,x2,x3,x4) = max{90, x1 + 14, x2 + 62, x3 + 45, x4 + 88}
        uTake1_A(x1) = max{46, x1 + 45}
        take_A(x1,x2) = max{89, x1 + 62, x2 + 88}
        length_A(x1) = x1 + 40
        isNatList_A(x1) = max{27, x1 + 26}
        a__isNatList#_A(x1) = max{44, x1 + 40}
        cons_A(x1,x2) = max{x1 - 12, x2}
        a__isNat_A(x1) = max{2, x1 - 3}
        a__isNatList_A(x1) = max{27, x1 + 26}
        isNatIList_A(x1) = x1 + 43
        a__isNatIList#_A(x1) = x1 + 57
        a__isNatIList_A(x1) = x1 + 43
        and_A(x1,x2) = max{x1 + 16, x2}
        mark_A(x1) = x1
        a__and_A(x1,x2) = max{x1 + 16, x2}
        a__zeros_A = 0
        |0|_A = 12
        zeros_A = 0
        a__take_A(x1,x2) = max{89, x1 + 62, x2 + 88}
        a__uTake1_A(x1) = max{46, x1 + 45}
        nil_A = 7
        a__uTake2_A(x1,x2,x3,x4) = max{90, x1 + 14, x2 + 62, x3 + 45, x4 + 88}
        a__length_A(x1) = x1 + 40
        a__uLength_A(x1,x2) = max{x1 + 2, x2 + 40}
        isNat_A(x1) = max{2, x1 - 3}
  
    precedence:
    
      tt = a__isNat = a__isNatList = a__isNatIList = mark = a__and > isNatIList > isNatList > a__take > and = a__zeros = |0| = a__uTake1 = nil > isNat > uTake2 = take = cons = a__uTake2 > uTake1 = zeros = a__length > uLength = a__uLength > a__and# = mark# = s = a__isNatList# = a__isNatIList# > length
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(uTake2) = []
      pi(uTake1) = [1]
      pi(take) = [1]
      pi(length) = []
      pi(isNatList) = [1]
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(a__isNatIList) = []
      pi(and) = [1]
      pi(mark) = []
      pi(a__and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = [1]
      pi(a__uTake1) = [1]
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(isNatList(X)) -> a__isNatList#(X)
p8: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p9: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p10: mark#(isNatIList(X)) -> a__isNatIList#(X)
p11: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: mark#(and(X1,X2)) -> mark#(X2)
p14: mark#(and(X1,X2)) -> mark#(X1)
p15: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X1)
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatIList(X)) -> a__isNatIList#(X)
p6: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p7: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p8: mark#(isNatList(X)) -> a__isNatList#(X)
p9: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p10: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p11: mark#(take(X1,X2)) -> mark#(X1)
p12: mark#(uTake1(X)) -> mark#(X)
p13: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p14: mark#(uLength(X1,X2)) -> mark#(X1)
p15: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 + 4, x2}
        tt_A = 9
        mark#_A(x1) = max{12, x1}
        and_A(x1,x2) = max{13, x1 + 6, x2}
        mark_A(x1) = max{7, x1}
        isNatIList_A(x1) = x1 + 25
        a__isNatIList#_A(x1) = x1 + 25
        cons_A(x1,x2) = max{1, x1 - 5, x2}
        a__isNat_A(x1) = max{10, x1 - 11}
        a__isNatIList_A(x1) = x1 + 25
        isNatList_A(x1) = max{25, x1}
        a__isNatList#_A(x1) = max{25, x1}
        a__isNatList_A(x1) = max{25, x1}
        take_A(x1,x2) = max{40, x1 + 25, x2 + 33}
        uTake1_A(x1) = max{6, x1}
        uTake2_A(x1,x2,x3,x4) = max{41, x1 + 8, x2 + 25, x3 + 11, x4 + 33}
        uLength_A(x1,x2) = max{62, x1 + 37, x2 + 37}
        s_A(x1) = max{16, x1}
        a__and_A(x1,x2) = max{13, x1 + 6, x2}
        a__zeros_A = 7
        |0|_A = 10
        zeros_A = 0
        a__take_A(x1,x2) = max{40, x1 + 25, x2 + 33}
        a__uTake1_A(x1) = max{7, x1}
        nil_A = 9
        a__uTake2_A(x1,x2,x3,x4) = max{41, x1 + 8, x2 + 25, x3 + 11, x4 + 33}
        a__length_A(x1) = max{62, x1 + 37}
        a__uLength_A(x1,x2) = max{62, x1 + 37, x2 + 37}
        length_A(x1) = max{62, x1 + 37}
        isNat_A(x1) = max{10, x1 - 11}
  
    precedence:
    
      a__length = length > uLength = a__uLength > tt = isNatIList = a__isNat = a__isNatIList = isNatList = a__isNatList = isNat > and = mark = a__and = a__zeros = a__take > a__uTake2 > cons > zeros > |0| > uTake1 = uTake2 = a__uTake1 = nil > a__and# = mark# = a__isNatIList# = a__isNatList# = take = s
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = [2]
      pi(mark) = [1]
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(cons) = [2]
      pi(a__isNat) = []
      pi(a__isNatIList) = [1]
      pi(isNatList) = [1]
      pi(a__isNatList#) = []
      pi(a__isNatList) = [1]
      pi(take) = [1]
      pi(uTake1) = [1]
      pi(uTake2) = []
      pi(uLength) = []
      pi(s) = []
      pi(a__and) = [2]
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = [1]
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(length) = []
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X2)
p4: mark#(isNatIList(X)) -> a__isNatIList#(X)
p5: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p6: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p7: mark#(isNatList(X)) -> a__isNatList#(X)
p8: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p9: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p10: mark#(take(X1,X2)) -> mark#(X1)
p11: mark#(uTake1(X)) -> mark#(X)
p12: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p13: mark#(uLength(X1,X2)) -> mark#(X1)
p14: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(isNatList(X)) -> a__isNatList#(X)
p8: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p9: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p10: mark#(isNatIList(X)) -> a__isNatIList#(X)
p11: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p12: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p13: mark#(and(X1,X2)) -> mark#(X2)
p14: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = x2 + 113
        tt_A = 77
        mark#_A(x1) = max{113, x1 + 109}
        s_A(x1) = max{135, x1 + 9}
        uLength_A(x1,x2) = max{x1 + 59, x2 + 112}
        uTake2_A(x1,x2,x3,x4) = max{135, x1 + 5, x2 + 9, x3 + 17, x4 + 123}
        uTake1_A(x1) = max{78, x1}
        take_A(x1,x2) = max{126, x1, x2 + 114}
        isNatList_A(x1) = x1 + 37
        a__isNatList#_A(x1) = max{146, x1 + 141}
        cons_A(x1,x2) = max{x1 - 6, x2 + 9}
        a__isNat_A(x1) = max{78, x1 + 19}
        a__isNatList_A(x1) = x1 + 37
        isNatIList_A(x1) = x1 + 106
        a__isNatIList#_A(x1) = x1 + 210
        a__isNatIList_A(x1) = x1 + 106
        and_A(x1,x2) = max{30, x2 + 6}
        mark_A(x1) = max{11, x1}
        a__and_A(x1,x2) = max{30, x2 + 6}
        a__zeros_A = 9
        |0|_A = 10
        zeros_A = 0
        a__take_A(x1,x2) = max{126, x1, x2 + 114}
        a__uTake1_A(x1) = max{78, x1}
        nil_A = 77
        a__uTake2_A(x1,x2,x3,x4) = max{135, x1 + 5, x2 + 9, x3 + 17, x4 + 123}
        a__length_A(x1) = max{114, x1 + 103}
        a__uLength_A(x1,x2) = max{x1 + 59, x2 + 112}
        length_A(x1) = max{114, x1 + 103}
        isNat_A(x1) = max{78, x1 + 19}
  
    precedence:
    
      a__zeros > zeros = nil > uTake1 = take = isNatIList = a__isNatIList = a__take = a__uTake1 > a__length = length > a__and# = mark# = a__isNatList# = a__isNatIList# > isNatList = a__isNatList > uLength = a__uLength > tt = s = a__isNat = and = mark = a__and = a__uTake2 = isNat > |0| > cons > uTake2
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(uTake2) = [2]
      pi(uTake1) = []
      pi(take) = []
      pi(isNatList) = [1]
      pi(a__isNatList#) = []
      pi(cons) = [2]
      pi(a__isNat) = [1]
      pi(a__isNatList) = [1]
      pi(isNatIList) = [1]
      pi(a__isNatIList#) = []
      pi(a__isNatIList) = [1]
      pi(and) = []
      pi(mark) = [1]
      pi(a__and) = [2]
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [2]
      pi(a__length) = []
      pi(a__uLength) = []
      pi(length) = []
      pi(isNat) = [1]

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(uTake1(X)) -> mark#(X)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(isNatList(X)) -> a__isNatList#(X)
p8: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p9: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p10: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)
p11: a__isNatIList#(cons(N,IL)) -> a__and#(a__isNat(N),a__isNatIList(IL))
p12: mark#(and(X1,X2)) -> mark#(X2)
p13: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__isNatIList#(cons(N,IL)) -> a__isNatIList#(IL)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X2)
p4: mark#(isNatList(X)) -> a__isNatList#(X)
p5: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p6: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p7: mark#(take(X1,X2)) -> mark#(X1)
p8: mark#(uTake1(X)) -> mark#(X)
p9: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p10: mark#(uLength(X1,X2)) -> mark#(X1)
p11: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 - 9, x2 + 2}
        tt_A = 11
        mark#_A(x1) = x1 + 2
        and_A(x1,x2) = max{x1 + 34, x2}
        mark_A(x1) = x1
        isNatList_A(x1) = x1 + 15
        a__isNatList#_A(x1) = x1 + 17
        cons_A(x1,x2) = max{x1 + 34, x2}
        a__isNat_A(x1) = max{1, x1 - 24}
        a__isNatList_A(x1) = x1 + 15
        take_A(x1,x2) = max{x1 + 18, x2 + 33}
        uTake1_A(x1) = max{4, x1 + 3}
        uTake2_A(x1,x2,x3,x4) = max{x1 + 7, x2 + 18, x3 + 34, x4 + 33}
        uLength_A(x1,x2) = max{x1 + 25, x2 + 41}
        s_A(x1) = max{40, x1}
        a__and_A(x1,x2) = max{x1 + 34, x2}
        a__isNatIList_A(x1) = x1 + 25
        zeros_A = 71
        a__zeros_A = 71
        |0|_A = 36
        a__take_A(x1,x2) = max{x1 + 18, x2 + 33}
        a__uTake1_A(x1) = max{4, x1 + 3}
        nil_A = 1
        a__uTake2_A(x1,x2,x3,x4) = max{x1 + 7, x2 + 18, x3 + 34, x4 + 33}
        a__length_A(x1) = x1 + 41
        a__uLength_A(x1,x2) = max{x1 + 25, x2 + 41}
        isNatIList_A(x1) = x1 + 25
        length_A(x1) = x1 + 41
        isNat_A(x1) = max{1, x1 - 24}
  
    precedence:
    
      mark = a__isNatList = a__and = a__isNatIList > a__length > a__uLength > a__isNat = take = a__take > tt > a__uTake2 > isNatList > length > uTake2 > |0| > a__uTake1 > a__zeros > uTake1 > cons > s = zeros = nil > a__and# = mark# = and = a__isNatList# = uLength = isNatIList = isNat
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(and) = [1]
      pi(mark) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(take) = [1, 2]
      pi(uTake1) = [1]
      pi(uTake2) = []
      pi(uLength) = []
      pi(s) = []
      pi(a__and) = []
      pi(a__isNatIList) = []
      pi(zeros) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(a__take) = [1, 2]
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [1, 2, 3]
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNatIList) = []
      pi(length) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p8

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X2)
p4: mark#(isNatList(X)) -> a__isNatList#(X)
p5: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p6: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p7: mark#(take(X1,X2)) -> mark#(X1)
p8: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p9: mark#(uLength(X1,X2)) -> mark#(X1)
p10: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p5: mark#(take(X1,X2)) -> mark#(X1)
p6: mark#(isNatList(X)) -> a__isNatList#(X)
p7: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p8: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p9: mark#(and(X1,X2)) -> mark#(X2)
p10: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 - 21, x2 + 8}
        tt_A = 3
        mark#_A(x1) = x1 + 8
        s_A(x1) = max{4, x1}
        uLength_A(x1,x2) = max{31, x1, x2 - 8}
        uTake2_A(x1,x2,x3,x4) = max{x1 + 28, x2 + 48, x3 + 33, x4 + 49}
        take_A(x1,x2) = max{x1 + 48, x2 + 49}
        isNatList_A(x1) = max{10, x1 - 8}
        a__isNatList#_A(x1) = x1
        cons_A(x1,x2) = max{x1 + 30, x2}
        a__isNat_A(x1) = x1 + 21
        a__isNatList_A(x1) = max{10, x1 - 8}
        and_A(x1,x2) = max{x1 - 1, x2}
        mark_A(x1) = x1
        a__and_A(x1,x2) = max{x1 - 1, x2}
        a__isNatIList_A(x1) = x1 + 21
        zeros_A = 31
        a__zeros_A = 31
        |0|_A = 1
        a__take_A(x1,x2) = max{x1 + 48, x2 + 49}
        a__uTake1_A(x1) = max{0, x1 - 1}
        nil_A = 1
        a__uTake2_A(x1,x2,x3,x4) = max{x1 + 28, x2 + 48, x3 + 33, x4 + 49}
        a__length_A(x1) = max{31, x1 - 8}
        a__uLength_A(x1,x2) = max{31, x1, x2 - 8}
        isNatIList_A(x1) = x1 + 21
        length_A(x1) = max{31, x1 - 8}
        uTake1_A(x1) = max{0, x1 - 1}
        isNat_A(x1) = x1 + 21
  
    precedence:
    
      tt = uTake2 = take = cons = a__isNat = a__isNatList = mark = a__and = a__isNatIList = zeros = a__zeros = |0| = a__take = a__uTake1 = a__uTake2 = isNatIList > isNatList > and = nil = a__length = length > isNat > a__and# = mark# = a__isNatList# > uTake1 > uLength = a__uLength > s
    
    partial status:
  
      pi(a__and#) = []
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(uTake2) = []
      pi(take) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(and) = []
      pi(mark) = []
      pi(a__and) = []
      pi(a__isNatIList) = []
      pi(zeros) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNatIList) = []
      pi(length) = []
      pi(uTake1) = []
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(take(X1,X2)) -> mark#(X1)
p5: mark#(isNatList(X)) -> a__isNatList#(X)
p6: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: mark#(and(X1,X2)) -> mark#(X2)
p9: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> a__and#(mark(X1),mark(X2))
p3: mark#(and(X1,X2)) -> mark#(X2)
p4: mark#(isNatList(X)) -> a__isNatList#(X)
p5: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p6: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p7: mark#(take(X1,X2)) -> mark#(X1)
p8: mark#(uLength(X1,X2)) -> mark#(X1)
p9: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{x1 - 106, x2 + 4}
        tt_A = 134
        mark#_A(x1) = x1 + 3
        and_A(x1,x2) = max{83, x1 - 49, x2 + 23}
        mark_A(x1) = max{59, x1}
        isNatList_A(x1) = x1 + 40
        a__isNatList#_A(x1) = x1 + 29
        cons_A(x1,x2) = max{55, x1 - 2, x2 + 45}
        a__isNat_A(x1) = max{133, x1 + 75}
        a__isNatList_A(x1) = x1 + 40
        take_A(x1,x2) = max{204, x1 + 132, x2 + 107}
        uLength_A(x1,x2) = max{117, x1 + 33, x2 + 106}
        s_A(x1) = max{118, x1 + 45}
        a__and_A(x1,x2) = max{83, x1 - 49, x2 + 23}
        a__isNatIList_A(x1) = max{136, x1 + 105}
        zeros_A = 0
        a__zeros_A = 58
        |0|_A = 60
        a__take_A(x1,x2) = max{204, x1 + 132, x2 + 107}
        a__uTake1_A(x1) = max{58, x1 - 38}
        nil_A = 95
        a__uTake2_A(x1,x2,x3,x4) = max{249, x2 + 177, x3 + 105, x4 + 152}
        a__length_A(x1) = max{121, x1 + 61}
        a__uLength_A(x1,x2) = max{117, x1 + 33, x2 + 106}
        isNatIList_A(x1) = max{136, x1 + 105}
        length_A(x1) = max{121, x1 + 61}
        uTake1_A(x1) = max{20, x1 - 38}
        uTake2_A(x1,x2,x3,x4) = max{249, x2 + 177, x3 + 105, x4 + 152}
        isNat_A(x1) = max{133, x1 + 75}
  
    precedence:
    
      a__isNat = a__isNatIList = isNatIList = isNat > and = mark = a__isNatList = a__and = zeros = a__zeros = |0| = a__take = a__uTake1 = uTake1 > a__uTake2 = a__length = length > tt = cons > take = uTake2 > s = a__uLength > a__and# = mark# = isNatList = a__isNatList# = nil > uLength
    
    partial status:
  
      pi(a__and#) = [2]
      pi(tt) = []
      pi(mark#) = [1]
      pi(and) = [2]
      pi(mark) = [1]
      pi(isNatList) = [1]
      pi(a__isNatList#) = [1]
      pi(cons) = [2]
      pi(a__isNat) = []
      pi(a__isNatList) = [1]
      pi(take) = [1]
      pi(uLength) = [1]
      pi(s) = []
      pi(a__and) = [2]
      pi(a__isNatIList) = []
      pi(zeros) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(nil) = []
      pi(a__uTake2) = [2, 3]
      pi(a__length) = []
      pi(a__uLength) = []
      pi(isNatIList) = []
      pi(length) = []
      pi(uTake1) = []
      pi(uTake2) = [3]
      pi(isNat) = []

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: a__and#(tt(),T) -> mark#(T)
p2: mark#(and(X1,X2)) -> mark#(X2)
p3: mark#(isNatList(X)) -> a__isNatList#(X)
p4: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p5: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p6: mark#(take(X1,X2)) -> mark#(X1)
p7: mark#(uLength(X1,X2)) -> mark#(X1)
p8: mark#(s(X)) -> mark#(X)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(take(X1,X2)) -> mark#(X1)
p5: mark#(isNatList(X)) -> a__isNatList#(X)
p6: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p7: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p8: mark#(and(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

Take the reduction pair:

  weighted path order
  
    base order:
  
      max/plus interpretations on natural numbers:
      
        a__and#_A(x1,x2) = max{2, x1 - 58, x2 + 1}
        tt_A = 86
        mark#_A(x1) = max{0, x1 - 1}
        s_A(x1) = max{86, x1 + 12}
        uLength_A(x1,x2) = max{x1, x2 + 12}
        take_A(x1,x2) = max{89, x1 + 47, x2 + 16}
        isNatList_A(x1) = max{3, x1}
        a__isNatList#_A(x1) = max{1, x1 - 2}
        cons_A(x1,x2) = max{x1 - 17, x2 + 12}
        a__isNat_A(x1) = max{60, x1 + 39}
        a__isNatList_A(x1) = max{5, x1}
        and_A(x1,x2) = max{1, x1 - 56, x2}
        a__zeros_A = 30
        |0|_A = 47
        zeros_A = 17
        a__take_A(x1,x2) = max{89, x1 + 47, x2 + 16}
        a__uTake1_A(x1) = 94
        a__isNatIList_A(x1) = max{87, x1 + 12}
        nil_A = 87
        a__uTake2_A(x1,x2,x3,x4) = max{90, x1 + 16, x2 + 59, x3 - 1, x4 + 28}
        a__and_A(x1,x2) = max{12, x1 - 56, x2}
        mark_A(x1) = max{30, x1}
        a__length_A(x1) = max{11, x1}
        a__uLength_A(x1,x2) = max{x1, x2 + 12}
        length_A(x1) = max{6, x1}
        uTake1_A(x1) = 94
        uTake2_A(x1,x2,x3,x4) = max{90, x1 + 16, x2 + 59, x3 - 1, x4 + 28}
        isNatIList_A(x1) = max{87, x1 + 12}
        isNat_A(x1) = max{60, x1 + 39}
  
    precedence:
    
      tt = take = a__isNatList# = cons = a__isNat = a__isNatList = and = a__zeros = |0| = a__take = a__uTake1 = a__isNatIList = nil = a__uTake2 = a__and = mark = a__length = length = uTake1 = uTake2 = isNat > a__and# = mark# = s = uLength = isNatList = zeros = a__uLength = isNatIList
    
    partial status:
  
      pi(a__and#) = [2]
      pi(tt) = []
      pi(mark#) = []
      pi(s) = []
      pi(uLength) = []
      pi(take) = []
      pi(isNatList) = []
      pi(a__isNatList#) = []
      pi(cons) = []
      pi(a__isNat) = []
      pi(a__isNatList) = []
      pi(and) = []
      pi(a__zeros) = []
      pi(|0|) = []
      pi(zeros) = []
      pi(a__take) = []
      pi(a__uTake1) = []
      pi(a__isNatIList) = []
      pi(nil) = []
      pi(a__uTake2) = []
      pi(a__and) = []
      pi(mark) = []
      pi(a__length) = []
      pi(a__uLength) = []
      pi(length) = []
      pi(uTake1) = []
      pi(uTake2) = []
      pi(isNatIList) = []
      pi(isNat) = []

The next rules are strictly ordered:

  p5

We remove them from the problem.

-- SCC decomposition.

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

p1: a__and#(tt(),T) -> mark#(T)
p2: mark#(s(X)) -> mark#(X)
p3: mark#(uLength(X1,X2)) -> mark#(X1)
p4: mark#(take(X1,X2)) -> mark#(X1)
p5: a__isNatList#(cons(N,L)) -> a__isNatList#(L)
p6: a__isNatList#(cons(N,L)) -> a__and#(a__isNat(N),a__isNatList(L))
p7: mark#(and(X1,X2)) -> mark#(X2)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: a__isNatList#(cons(N,L)) -> a__isNatList#(L)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

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

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: mark#(s(X)) -> mark#(X)
p2: mark#(and(X1,X2)) -> mark#(X2)
p3: mark#(take(X1,X2)) -> mark#(X1)
p4: mark#(uLength(X1,X2)) -> mark#(X1)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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) = max{4, x1 + 2}
        s_A(x1) = x1
        and_A(x1,x2) = max{x1 + 5, x2 + 5}
        take_A(x1,x2) = max{x1 + 2, x2}
        uLength_A(x1,x2) = max{2, x1, x2}
  
    precedence:
    
      mark# = s = and = take = uLength
    
    partial status:
  
      pi(mark#) = []
      pi(s) = [1]
      pi(and) = [2]
      pi(take) = [2]
      pi(uLength) = [2]

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#(s(X)) -> mark#(X)
p2: mark#(take(X1,X2)) -> mark#(X1)
p3: mark#(uLength(X1,X2)) -> mark#(X1)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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#(s(X)) -> mark#(X)
p2: mark#(uLength(X1,X2)) -> mark#(X1)
p3: mark#(take(X1,X2)) -> mark#(X1)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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) = max{4, x1 + 2}
        s_A(x1) = max{3, x1 + 1}
        uLength_A(x1,x2) = max{x1 + 2, x2 + 1}
        take_A(x1,x2) = max{x1 + 1, x2 + 1}
  
    precedence:
    
      s = uLength = take > mark#
    
    partial status:
  
      pi(mark#) = []
      pi(s) = [1]
      pi(uLength) = [2]
      pi(take) = [2]

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

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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
        uLength_A(x1,x2) = max{x1 + 2, x2 + 2}
        take_A(x1,x2) = max{x1, x2}
  
    precedence:
    
      mark# = uLength = take
    
    partial status:
  
      pi(mark#) = []
      pi(uLength) = [2]
      pi(take) = [2]

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

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

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

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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 + 3
        take_A(x1,x2) = max{x1 + 1, x2}
  
    precedence:
    
      mark# = take
    
    partial status:
  
      pi(mark#) = []
      pi(take) = [2]

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: a__isNat#(s(N)) -> a__isNat#(N)

and R consists of:

r1: a__and(tt(),T) -> mark(T)
r2: a__isNatIList(IL) -> a__isNatList(IL)
r3: a__isNat(|0|()) -> tt()
r4: a__isNat(s(N)) -> a__isNat(N)
r5: a__isNat(length(L)) -> a__isNatList(L)
r6: a__isNatIList(zeros()) -> tt()
r7: a__isNatIList(cons(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r8: a__isNatList(nil()) -> tt()
r9: a__isNatList(cons(N,L)) -> a__and(a__isNat(N),a__isNatList(L))
r10: a__isNatList(take(N,IL)) -> a__and(a__isNat(N),a__isNatIList(IL))
r11: a__zeros() -> cons(|0|(),zeros())
r12: a__take(|0|(),IL) -> a__uTake1(a__isNatIList(IL))
r13: a__uTake1(tt()) -> nil()
r14: a__take(s(M),cons(N,IL)) -> a__uTake2(a__and(a__isNat(M),a__and(a__isNat(N),a__isNatIList(IL))),M,N,IL)
r15: a__uTake2(tt(),M,N,IL) -> cons(mark(N),take(M,IL))
r16: a__length(cons(N,L)) -> a__uLength(a__and(a__isNat(N),a__isNatList(L)),L)
r17: a__uLength(tt(),L) -> s(a__length(mark(L)))
r18: mark(and(X1,X2)) -> a__and(mark(X1),mark(X2))
r19: mark(isNatIList(X)) -> a__isNatIList(X)
r20: mark(isNatList(X)) -> a__isNatList(X)
r21: mark(isNat(X)) -> a__isNat(X)
r22: mark(length(X)) -> a__length(mark(X))
r23: mark(zeros()) -> a__zeros()
r24: mark(take(X1,X2)) -> a__take(mark(X1),mark(X2))
r25: mark(uTake1(X)) -> a__uTake1(mark(X))
r26: mark(uTake2(X1,X2,X3,X4)) -> a__uTake2(mark(X1),X2,X3,X4)
r27: mark(uLength(X1,X2)) -> a__uLength(mark(X1),X2)
r28: mark(tt()) -> tt()
r29: mark(|0|()) -> |0|()
r30: mark(s(X)) -> s(mark(X))
r31: mark(cons(X1,X2)) -> cons(mark(X1),X2)
r32: mark(nil()) -> nil()
r33: a__and(X1,X2) -> and(X1,X2)
r34: a__isNatIList(X) -> isNatIList(X)
r35: a__isNatList(X) -> isNatList(X)
r36: a__isNat(X) -> isNat(X)
r37: a__length(X) -> length(X)
r38: a__zeros() -> zeros()
r39: a__take(X1,X2) -> take(X1,X2)
r40: a__uTake1(X) -> uTake1(X)
r41: a__uTake2(X1,X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r42: a__uLength(X1,X2) -> uLength(X1,X2)

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:
      
        a__isNat#_A(x1) = x1 + 2
        s_A(x1) = x1 + 2
  
    precedence:
    
      a__isNat# = s
    
    partial status:
  
      pi(a__isNat#) = [1]
      pi(s) = [1]

The next rules are strictly ordered:

  p1

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