YES

We show the termination of the TRS R:

  active(and(tt(),T)) -> mark(T)
  active(isNatIList(IL)) -> mark(isNatList(IL))
  active(isNat(|0|())) -> mark(tt())
  active(isNat(s(N))) -> mark(isNat(N))
  active(isNat(length(L))) -> mark(isNatList(L))
  active(isNatIList(zeros())) -> mark(tt())
  active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
  active(isNatList(nil())) -> mark(tt())
  active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
  active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
  active(zeros()) -> mark(cons(|0|(),zeros()))
  active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
  active(uTake1(tt())) -> mark(nil())
  active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
  active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
  active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
  active(uLength(tt(),L)) -> mark(s(length(L)))
  mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
  mark(tt()) -> active(tt())
  mark(isNatIList(X)) -> active(isNatIList(X))
  mark(isNatList(X)) -> active(isNatList(X))
  mark(isNat(X)) -> active(isNat(X))
  mark(|0|()) -> active(|0|())
  mark(s(X)) -> active(s(mark(X)))
  mark(length(X)) -> active(length(mark(X)))
  mark(zeros()) -> active(zeros())
  mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
  mark(nil()) -> active(nil())
  mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
  mark(uTake1(X)) -> active(uTake1(mark(X)))
  mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
  mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
  and(mark(X1),X2) -> and(X1,X2)
  and(X1,mark(X2)) -> and(X1,X2)
  and(active(X1),X2) -> and(X1,X2)
  and(X1,active(X2)) -> and(X1,X2)
  isNatIList(mark(X)) -> isNatIList(X)
  isNatIList(active(X)) -> isNatIList(X)
  isNatList(mark(X)) -> isNatList(X)
  isNatList(active(X)) -> isNatList(X)
  isNat(mark(X)) -> isNat(X)
  isNat(active(X)) -> isNat(X)
  s(mark(X)) -> s(X)
  s(active(X)) -> s(X)
  length(mark(X)) -> length(X)
  length(active(X)) -> length(X)
  cons(mark(X1),X2) -> cons(X1,X2)
  cons(X1,mark(X2)) -> cons(X1,X2)
  cons(active(X1),X2) -> cons(X1,X2)
  cons(X1,active(X2)) -> cons(X1,X2)
  take(mark(X1),X2) -> take(X1,X2)
  take(X1,mark(X2)) -> take(X1,X2)
  take(active(X1),X2) -> take(X1,X2)
  take(X1,active(X2)) -> take(X1,X2)
  uTake1(mark(X)) -> uTake1(X)
  uTake1(active(X)) -> uTake1(X)
  uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
  uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
  uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
  uLength(mark(X1),X2) -> uLength(X1,X2)
  uLength(X1,mark(X2)) -> uLength(X1,X2)
  uLength(active(X1),X2) -> uLength(X1,X2)
  uLength(X1,active(X2)) -> uLength(X1,X2)

-- SCC decomposition.

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

p1: active#(and(tt(),T)) -> mark#(T)
p2: active#(isNatIList(IL)) -> mark#(isNatList(IL))
p3: active#(isNatIList(IL)) -> isNatList#(IL)
p4: active#(isNat(|0|())) -> mark#(tt())
p5: active#(isNat(s(N))) -> mark#(isNat(N))
p6: active#(isNat(s(N))) -> isNat#(N)
p7: active#(isNat(length(L))) -> mark#(isNatList(L))
p8: active#(isNat(length(L))) -> isNatList#(L)
p9: active#(isNatIList(zeros())) -> mark#(tt())
p10: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p11: active#(isNatIList(cons(N,IL))) -> and#(isNat(N),isNatIList(IL))
p12: active#(isNatIList(cons(N,IL))) -> isNat#(N)
p13: active#(isNatIList(cons(N,IL))) -> isNatIList#(IL)
p14: active#(isNatList(nil())) -> mark#(tt())
p15: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p16: active#(isNatList(cons(N,L))) -> and#(isNat(N),isNatList(L))
p17: active#(isNatList(cons(N,L))) -> isNat#(N)
p18: active#(isNatList(cons(N,L))) -> isNatList#(L)
p19: active#(isNatList(take(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p20: active#(isNatList(take(N,IL))) -> and#(isNat(N),isNatIList(IL))
p21: active#(isNatList(take(N,IL))) -> isNat#(N)
p22: active#(isNatList(take(N,IL))) -> isNatIList#(IL)
p23: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p24: active#(zeros()) -> cons#(|0|(),zeros())
p25: active#(take(|0|(),IL)) -> mark#(uTake1(isNatIList(IL)))
p26: active#(take(|0|(),IL)) -> uTake1#(isNatIList(IL))
p27: active#(take(|0|(),IL)) -> isNatIList#(IL)
p28: active#(uTake1(tt())) -> mark#(nil())
p29: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p30: active#(take(s(M),cons(N,IL))) -> uTake2#(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL)
p31: active#(take(s(M),cons(N,IL))) -> and#(isNat(M),and(isNat(N),isNatIList(IL)))
p32: active#(take(s(M),cons(N,IL))) -> isNat#(M)
p33: active#(take(s(M),cons(N,IL))) -> and#(isNat(N),isNatIList(IL))
p34: active#(take(s(M),cons(N,IL))) -> isNat#(N)
p35: active#(take(s(M),cons(N,IL))) -> isNatIList#(IL)
p36: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p37: active#(uTake2(tt(),M,N,IL)) -> cons#(N,take(M,IL))
p38: active#(uTake2(tt(),M,N,IL)) -> take#(M,IL)
p39: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p40: active#(length(cons(N,L))) -> uLength#(and(isNat(N),isNatList(L)),L)
p41: active#(length(cons(N,L))) -> and#(isNat(N),isNatList(L))
p42: active#(length(cons(N,L))) -> isNat#(N)
p43: active#(length(cons(N,L))) -> isNatList#(L)
p44: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p45: active#(uLength(tt(),L)) -> s#(length(L))
p46: active#(uLength(tt(),L)) -> length#(L)
p47: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p48: mark#(and(X1,X2)) -> and#(mark(X1),mark(X2))
p49: mark#(and(X1,X2)) -> mark#(X1)
p50: mark#(and(X1,X2)) -> mark#(X2)
p51: mark#(tt()) -> active#(tt())
p52: mark#(isNatIList(X)) -> active#(isNatIList(X))
p53: mark#(isNatList(X)) -> active#(isNatList(X))
p54: mark#(isNat(X)) -> active#(isNat(X))
p55: mark#(|0|()) -> active#(|0|())
p56: mark#(s(X)) -> active#(s(mark(X)))
p57: mark#(s(X)) -> s#(mark(X))
p58: mark#(s(X)) -> mark#(X)
p59: mark#(length(X)) -> active#(length(mark(X)))
p60: mark#(length(X)) -> length#(mark(X))
p61: mark#(length(X)) -> mark#(X)
p62: mark#(zeros()) -> active#(zeros())
p63: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p64: mark#(cons(X1,X2)) -> cons#(mark(X1),X2)
p65: mark#(cons(X1,X2)) -> mark#(X1)
p66: mark#(nil()) -> active#(nil())
p67: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p68: mark#(take(X1,X2)) -> take#(mark(X1),mark(X2))
p69: mark#(take(X1,X2)) -> mark#(X1)
p70: mark#(take(X1,X2)) -> mark#(X2)
p71: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p72: mark#(uTake1(X)) -> uTake1#(mark(X))
p73: mark#(uTake1(X)) -> mark#(X)
p74: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p75: mark#(uTake2(X1,X2,X3,X4)) -> uTake2#(mark(X1),X2,X3,X4)
p76: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p77: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p78: mark#(uLength(X1,X2)) -> uLength#(mark(X1),X2)
p79: mark#(uLength(X1,X2)) -> mark#(X1)
p80: and#(mark(X1),X2) -> and#(X1,X2)
p81: and#(X1,mark(X2)) -> and#(X1,X2)
p82: and#(active(X1),X2) -> and#(X1,X2)
p83: and#(X1,active(X2)) -> and#(X1,X2)
p84: isNatIList#(mark(X)) -> isNatIList#(X)
p85: isNatIList#(active(X)) -> isNatIList#(X)
p86: isNatList#(mark(X)) -> isNatList#(X)
p87: isNatList#(active(X)) -> isNatList#(X)
p88: isNat#(mark(X)) -> isNat#(X)
p89: isNat#(active(X)) -> isNat#(X)
p90: s#(mark(X)) -> s#(X)
p91: s#(active(X)) -> s#(X)
p92: length#(mark(X)) -> length#(X)
p93: length#(active(X)) -> length#(X)
p94: cons#(mark(X1),X2) -> cons#(X1,X2)
p95: cons#(X1,mark(X2)) -> cons#(X1,X2)
p96: cons#(active(X1),X2) -> cons#(X1,X2)
p97: cons#(X1,active(X2)) -> cons#(X1,X2)
p98: take#(mark(X1),X2) -> take#(X1,X2)
p99: take#(X1,mark(X2)) -> take#(X1,X2)
p100: take#(active(X1),X2) -> take#(X1,X2)
p101: take#(X1,active(X2)) -> take#(X1,X2)
p102: uTake1#(mark(X)) -> uTake1#(X)
p103: uTake1#(active(X)) -> uTake1#(X)
p104: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p105: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p106: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p107: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)
p108: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p109: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p110: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p111: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p112: uLength#(mark(X1),X2) -> uLength#(X1,X2)
p113: uLength#(X1,mark(X2)) -> uLength#(X1,X2)
p114: uLength#(active(X1),X2) -> uLength#(X1,X2)
p115: uLength#(X1,active(X2)) -> uLength#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p5, p7, p10, p15, p19, p23, p25, p29, p36, p39, p44, p47, p49, p50, p52, p53, p54, p56, p58, p59, p61, p62, p63, p65, p67, p69, p70, p71, p73, p74, p76, p77, p79}
  {p86, p87}
  {p88, p89}
  {p80, p81, p82, p83}
  {p84, p85}
  {p102, p103}
  {p104, p105, p106, p107, p108, p109, p110, p111}
  {p94, p95, p96, p97}
  {p98, p99, p100, p101}
  {p112, p113, p114, p115}
  {p90, p91}
  {p92, p93}


-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      active#_A(x1) = x1 + 8
      and_A(x1,x2) = max{5, x1, x2}
      tt_A = 1
      mark#_A(x1) = max{13, x1 + 8}
      uLength_A(x1,x2) = max{x1 + 6, x2 + 2}
      mark_A(x1) = x1
      s_A(x1) = max{2, x1}
      length_A(x1) = x1 + 2
      uTake2_A(x1,x2,x3,x4) = max{x1, x2 + 14, x3 + 10, x4}
      cons_A(x1,x2) = max{14, x1 + 10, x2}
      isNat_A(x1) = x1 + 3
      isNatList_A(x1) = max{3, x1 - 7}
      uTake1_A(x1) = x1 + 6
      take_A(x1,x2) = max{x1 + 14, x2}
      isNatIList_A(x1) = max{6, x1 - 7}
      |0|_A = 1
      zeros_A = 15
      active_A(x1) = x1
      nil_A = 0
    
    2. max/plus interpretations on natural numbers:
    
      active#_A(x1) = max{0, x1 - 8}
      and_A(x1,x2) = 12
      tt_A = 11
      mark#_A(x1) = 4
      uLength_A(x1,x2) = 12
      mark_A(x1) = 40
      s_A(x1) = 2
      length_A(x1) = 12
      uTake2_A(x1,x2,x3,x4) = 12
      cons_A(x1,x2) = 0
      isNat_A(x1) = 12
      isNatList_A(x1) = 12
      uTake1_A(x1) = 6
      take_A(x1,x2) = 12
      isNatIList_A(x1) = 12
      |0|_A = 11
      zeros_A = 12
      active_A(x1) = max{34, x1 + 28}
      nil_A = 12
    

The next rules are strictly ordered:

  p2, p8, p9, p12, p15, p16, p17, p24

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      active#_A(x1) = max{0, x1 - 13}
      and_A(x1,x2) = max{x1, x2}
      tt_A = 6
      mark#_A(x1) = max{0, x1 - 13}
      mark_A(x1) = max{7, x1}
      isNatIList_A(x1) = x1 + 16
      isNatList_A(x1) = max{15, x1 + 14}
      isNat_A(x1) = x1 + 14
      s_A(x1) = max{7, x1}
      length_A(x1) = max{7, x1}
      cons_A(x1,x2) = max{6, x1, x2}
      take_A(x1,x2) = max{39, x1 + 29, x2 + 31}
      uTake2_A(x1,x2,x3,x4) = max{39, x1 + 14, x2 + 29, x3 + 20, x4 + 31}
      uLength_A(x1,x2) = max{5, x2}
      active_A(x1) = max{7, x1}
      |0|_A = 7
      zeros_A = 0
      nil_A = 35
      uTake1_A(x1) = 35
    
    2. max/plus interpretations on natural numbers:
    
      active#_A(x1) = 0
      and_A(x1,x2) = 0
      tt_A = 33
      mark#_A(x1) = 0
      mark_A(x1) = 97
      isNatIList_A(x1) = 28
      isNatList_A(x1) = 82
      isNat_A(x1) = 23
      s_A(x1) = 0
      length_A(x1) = 65
      cons_A(x1,x2) = 14
      take_A(x1,x2) = 70
      uTake2_A(x1,x2,x3,x4) = 42
      uLength_A(x1,x2) = 28
      active_A(x1) = 97
      |0|_A = 10
      zeros_A = 0
      nil_A = 196
      uTake1_A(x1) = 133
    

The next rules are strictly ordered:

  p3, p17, p18, p21

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: active#(and(tt(),T)) -> mark#(T)
p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p3: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p4: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p7: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p8: mark#(length(X)) -> mark#(X)
p9: mark#(length(X)) -> active#(length(mark(X)))
p10: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(isNat(X)) -> active#(isNat(X))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(isNatList(X)) -> active#(isNatList(X))
p15: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p16: mark#(isNatIList(X)) -> active#(isNatIList(X))
p17: active#(isNat(length(L))) -> mark#(isNatList(L))
p18: mark#(and(X1,X2)) -> mark#(X2)
p19: mark#(and(X1,X2)) -> mark#(X1)
p20: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p21: active#(isNat(s(N))) -> mark#(isNat(N))

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      active#_A(x1) = max{2, x1 + 1}
      and_A(x1,x2) = max{x1 + 7, x2}
      tt_A = 6
      mark#_A(x1) = x1 + 1
      uLength_A(x1,x2) = max{17, x2 + 7}
      mark_A(x1) = x1
      s_A(x1) = max{6, x1}
      length_A(x1) = max{15, x1 + 7}
      uTake2_A(x1,x2,x3,x4) = max{x1 + 9, x2 + 27, x3 + 10, x4 + 22}
      cons_A(x1,x2) = max{x1 + 10, x2}
      isNat_A(x1) = x1 + 11
      isNatList_A(x1) = x1 + 12
      take_A(x1,x2) = max{x1 + 27, x2 + 22}
      isNatIList_A(x1) = x1 + 13
      active_A(x1) = max{5, x1}
      |0|_A = 6
      zeros_A = 16
      nil_A = 13
      uTake1_A(x1) = max{14, x1 + 6}
    
    2. max/plus interpretations on natural numbers:
    
      active#_A(x1) = 0
      and_A(x1,x2) = 24
      tt_A = 11
      mark#_A(x1) = 0
      uLength_A(x1,x2) = 32
      mark_A(x1) = 22
      s_A(x1) = 12
      length_A(x1) = 9
      uTake2_A(x1,x2,x3,x4) = 11
      cons_A(x1,x2) = 8
      isNat_A(x1) = 9
      isNatList_A(x1) = 9
      take_A(x1,x2) = 15
      isNatIList_A(x1) = 15
      active_A(x1) = 22
      |0|_A = 11
      zeros_A = 2
      nil_A = 11
      uTake1_A(x1) = 9
    

The next rules are strictly ordered:

  p8, p17, p19

We remove them from the problem.

-- SCC decomposition.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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}


-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      active#_A(x1) = max{0, x1 - 7}
      and_A(x1,x2) = max{39, x2 + 6}
      tt_A = 109
      mark#_A(x1) = max{24, x1 - 7}
      mark_A(x1) = max{32, x1}
      isNat_A(x1) = max{136, x1 + 130}
      s_A(x1) = max{73, x1 + 7}
      isNatIList_A(x1) = x1 + 86
      cons_A(x1,x2) = max{32, x2 + 7}
      isNatList_A(x1) = max{60, x1 + 36}
      take_A(x1,x2) = max{88, x1 + 23, x2 + 56}
      uTake2_A(x1,x2,x3,x4) = max{96, x2 + 30, x4 + 63}
      length_A(x1) = max{1, x1 - 1}
      uLength_A(x1,x2) = max{31, x1 - 36, x2 + 6}
      active_A(x1) = max{32, x1}
      |0|_A = 8
      zeros_A = 24
      nil_A = 88
      uTake1_A(x1) = 88
    
    2. max/plus interpretations on natural numbers:
    
      active#_A(x1) = 19
      and_A(x1,x2) = 16
      tt_A = 41
      mark#_A(x1) = 19
      mark_A(x1) = 15
      isNat_A(x1) = 8
      s_A(x1) = 25
      isNatIList_A(x1) = 14
      cons_A(x1,x2) = 25
      isNatList_A(x1) = 19
      take_A(x1,x2) = 19
      uTake2_A(x1,x2,x3,x4) = 18
      length_A(x1) = 5
      uLength_A(x1,x2) = 18
      active_A(x1) = 15
      |0|_A = 12
      zeros_A = 10
      nil_A = 18
      uTake1_A(x1) = 10
    

The next rules are strictly ordered:

  p1, p3, p4, p6, p8, p11

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p2: mark#(isNatIList(X)) -> active#(isNatIList(X))
p3: mark#(isNatList(X)) -> active#(isNatList(X))
p4: mark#(isNat(X)) -> active#(isNat(X))
p5: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p6: mark#(length(X)) -> active#(length(mark(X)))
p7: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p8: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p9: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p10: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p11: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p12: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p2: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p3: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p5: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p6: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p7: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p9: mark#(length(X)) -> active#(length(mark(X)))
p10: mark#(isNat(X)) -> active#(isNat(X))
p11: mark#(isNatList(X)) -> active#(isNatList(X))
p12: mark#(isNatIList(X)) -> active#(isNatIList(X))

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      mark#_A(x1) = x1 + 30
      and_A(x1,x2) = max{51, x2}
      active#_A(x1) = max{80, x1 + 2}
      mark_A(x1) = x1
      uLength_A(x1,x2) = 50
      tt_A = 59
      s_A(x1) = max{50, x1 - 1}
      length_A(x1) = 50
      cons_A(x1,x2) = 50
      isNat_A(x1) = 62
      isNatList_A(x1) = 62
      uTake2_A(x1,x2,x3,x4) = max{50, x1 + 1}
      take_A(x1,x2) = max{x1 + 42, x2 + 50}
      isNatIList_A(x1) = 62
      active_A(x1) = max{50, x1}
      |0|_A = 71
      zeros_A = 50
      nil_A = 50
      uTake1_A(x1) = x1 + 50
    
    2. max/plus interpretations on natural numbers:
    
      mark#_A(x1) = max{0, x1 - 29}
      and_A(x1,x2) = 44
      active#_A(x1) = 0
      mark_A(x1) = 24
      uLength_A(x1,x2) = 11
      tt_A = 24
      s_A(x1) = 28
      length_A(x1) = 26
      cons_A(x1,x2) = 21
      isNat_A(x1) = 8
      isNatList_A(x1) = 30
      uTake2_A(x1,x2,x3,x4) = 15
      take_A(x1,x2) = 0
      isNatIList_A(x1) = 34
      active_A(x1) = 24
      |0|_A = 28
      zeros_A = 15
      nil_A = 26
      uTake1_A(x1) = 14
    

The next rules are strictly ordered:

  p1, p8, p10, p11, p12

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p2: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p3: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p4: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p5: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p6: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p7: mark#(length(X)) -> active#(length(mark(X)))

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p2: mark#(length(X)) -> active#(length(mark(X)))
p3: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p4: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p6: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p7: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      active#_A(x1) = x1 + 116
      uLength_A(x1,x2) = 6
      tt_A = 12
      mark#_A(x1) = x1 + 121
      s_A(x1) = 0
      length_A(x1) = 12
      mark_A(x1) = 115
      uTake2_A(x1,x2,x3,x4) = 12
      cons_A(x1,x2) = 0
      take_A(x1,x2) = 3
      and_A(x1,x2) = 12
      isNat_A(x1) = 12
      isNatList_A(x1) = 12
      active_A(x1) = max{115, x1 + 103}
      isNatIList_A(x1) = 12
      |0|_A = 12
      zeros_A = 12
      nil_A = 12
      uTake1_A(x1) = 12
    
    2. max/plus interpretations on natural numbers:
    
      active#_A(x1) = max{0, x1 - 2}
      uLength_A(x1,x2) = 4
      tt_A = 24
      mark#_A(x1) = max{1, x1 - 1}
      s_A(x1) = 0
      length_A(x1) = 6
      mark_A(x1) = 82
      uTake2_A(x1,x2,x3,x4) = 72
      cons_A(x1,x2) = 70
      take_A(x1,x2) = 6
      and_A(x1,x2) = 8
      isNat_A(x1) = 8
      isNatList_A(x1) = 22
      active_A(x1) = 82
      isNatIList_A(x1) = 39
      |0|_A = 24
      zeros_A = 8
      nil_A = 24
      uTake1_A(x1) = 8
    

The next rules are strictly ordered:

  p1, p2, p3, p4, p5, p6, p7

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      isNatList#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      isNatList#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      isNat#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      isNat#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{3, x1 + 2}
      active_A(x1) = max{1, x1}
    
    2. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: and#(mark(X1),X2) -> and#(X1,X2)
p2: and#(active(X1),X2) -> and#(X1,X2)
p3: and#(X1,active(X2)) -> and#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: and#(mark(X1),X2) -> and#(X1,X2)
p2: and#(active(X1),X2) -> and#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = x1
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      and#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      isNatIList#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      isNatIList#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake1#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      uTake1#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p5: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p6: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)
p7: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p8: uTake2#(X1,mark(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = max{0, x2 - 1}
      mark_A(x1) = max{3, x1 + 2}
      active_A(x1) = x1 + 1
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      mark_A(x1) = 0
      active_A(x1) = x1
    

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: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p5: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p6: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)
p7: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

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


-- Reduction pair.

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

p1: uTake2#(mark(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(active(X1),X2,X3,X4) -> uTake2#(X1,X2,X3,X4)
p5: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p6: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p7: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x1 + 1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      mark_A(x1) = x1
      active_A(x1) = x1
    

The next rules are strictly ordered:

  p1, p4

We remove them from the problem.

-- SCC decomposition.

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

p1: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p5: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p5}


-- Reduction pair.

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

p1: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p5: uTake2#(X1,X2,X3,mark(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x4 + 2
      mark_A(x1) = x1 + 1
      active_A(x1) = max{1, x1}
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      mark_A(x1) = x1
      active_A(x1) = 0
    

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: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4}


-- Reduction pair.

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

p1: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,active(X3),X4) -> uTake2#(X1,X2,X3,X4)
p4: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x3 + 3
      mark_A(x1) = max{1, x1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: uTake2#(X1,X2,mark(X3),X4) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p3: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x3
      mark_A(x1) = x1 + 1
      active_A(x1) = 0
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      mark_A(x1) = x1
      active_A(x1) = 0
    

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: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)
p2: uTake2#(X1,active(X2),X3,X4) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x2
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: uTake2#(X1,X2,X3,active(X4)) -> uTake2#(X1,X2,X3,X4)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = x4
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      uTake2#_A(x1,x2,x3,x4) = 0
      active_A(x1) = 0
    

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{3, x1 + 2}
      active_A(x1) = max{1, x1}
    
    2. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: cons#(mark(X1),X2) -> cons#(X1,X2)
p2: cons#(active(X1),X2) -> cons#(X1,X2)
p3: cons#(X1,active(X2)) -> cons#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: cons#(mark(X1),X2) -> cons#(X1,X2)
p2: cons#(active(X1),X2) -> cons#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = x1
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      cons#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

The next rules are strictly ordered:

  p1, p2

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

-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{3, x1 + 2}
      active_A(x1) = max{1, x1}
    
    2. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: take#(mark(X1),X2) -> take#(X1,X2)
p2: take#(active(X1),X2) -> take#(X1,X2)
p3: take#(X1,active(X2)) -> take#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: take#(mark(X1),X2) -> take#(X1,X2)
p2: take#(active(X1),X2) -> take#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = x1
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      take#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{3, x1 + 2}
      active_A(x1) = max{1, x1}
    
    2. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: uLength#(mark(X1),X2) -> uLength#(X1,X2)
p2: uLength#(active(X1),X2) -> uLength#(X1,X2)
p3: uLength#(X1,active(X2)) -> uLength#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = x2 + 2
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(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: uLength#(mark(X1),X2) -> uLength#(X1,X2)
p2: uLength#(active(X1),X2) -> uLength#(X1,X2)

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = x1
      mark_A(x1) = max{2, x1 + 1}
      active_A(x1) = max{2, x1 + 1}
    
    2. max/plus interpretations on natural numbers:
    
      uLength#_A(x1,x2) = 0
      mark_A(x1) = 0
      active_A(x1) = 0
    

The next rules are strictly ordered:

  p1, p2

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

-- Reduction pair.

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

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      s#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      s#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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

and R consists of:

r1: active(and(tt(),T)) -> mark(T)
r2: active(isNatIList(IL)) -> mark(isNatList(IL))
r3: active(isNat(|0|())) -> mark(tt())
r4: active(isNat(s(N))) -> mark(isNat(N))
r5: active(isNat(length(L))) -> mark(isNatList(L))
r6: active(isNatIList(zeros())) -> mark(tt())
r7: active(isNatIList(cons(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r8: active(isNatList(nil())) -> mark(tt())
r9: active(isNatList(cons(N,L))) -> mark(and(isNat(N),isNatList(L)))
r10: active(isNatList(take(N,IL))) -> mark(and(isNat(N),isNatIList(IL)))
r11: active(zeros()) -> mark(cons(|0|(),zeros()))
r12: active(take(|0|(),IL)) -> mark(uTake1(isNatIList(IL)))
r13: active(uTake1(tt())) -> mark(nil())
r14: active(take(s(M),cons(N,IL))) -> mark(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
r15: active(uTake2(tt(),M,N,IL)) -> mark(cons(N,take(M,IL)))
r16: active(length(cons(N,L))) -> mark(uLength(and(isNat(N),isNatList(L)),L))
r17: active(uLength(tt(),L)) -> mark(s(length(L)))
r18: mark(and(X1,X2)) -> active(and(mark(X1),mark(X2)))
r19: mark(tt()) -> active(tt())
r20: mark(isNatIList(X)) -> active(isNatIList(X))
r21: mark(isNatList(X)) -> active(isNatList(X))
r22: mark(isNat(X)) -> active(isNat(X))
r23: mark(|0|()) -> active(|0|())
r24: mark(s(X)) -> active(s(mark(X)))
r25: mark(length(X)) -> active(length(mark(X)))
r26: mark(zeros()) -> active(zeros())
r27: mark(cons(X1,X2)) -> active(cons(mark(X1),X2))
r28: mark(nil()) -> active(nil())
r29: mark(take(X1,X2)) -> active(take(mark(X1),mark(X2)))
r30: mark(uTake1(X)) -> active(uTake1(mark(X)))
r31: mark(uTake2(X1,X2,X3,X4)) -> active(uTake2(mark(X1),X2,X3,X4))
r32: mark(uLength(X1,X2)) -> active(uLength(mark(X1),X2))
r33: and(mark(X1),X2) -> and(X1,X2)
r34: and(X1,mark(X2)) -> and(X1,X2)
r35: and(active(X1),X2) -> and(X1,X2)
r36: and(X1,active(X2)) -> and(X1,X2)
r37: isNatIList(mark(X)) -> isNatIList(X)
r38: isNatIList(active(X)) -> isNatIList(X)
r39: isNatList(mark(X)) -> isNatList(X)
r40: isNatList(active(X)) -> isNatList(X)
r41: isNat(mark(X)) -> isNat(X)
r42: isNat(active(X)) -> isNat(X)
r43: s(mark(X)) -> s(X)
r44: s(active(X)) -> s(X)
r45: length(mark(X)) -> length(X)
r46: length(active(X)) -> length(X)
r47: cons(mark(X1),X2) -> cons(X1,X2)
r48: cons(X1,mark(X2)) -> cons(X1,X2)
r49: cons(active(X1),X2) -> cons(X1,X2)
r50: cons(X1,active(X2)) -> cons(X1,X2)
r51: take(mark(X1),X2) -> take(X1,X2)
r52: take(X1,mark(X2)) -> take(X1,X2)
r53: take(active(X1),X2) -> take(X1,X2)
r54: take(X1,active(X2)) -> take(X1,X2)
r55: uTake1(mark(X)) -> uTake1(X)
r56: uTake1(active(X)) -> uTake1(X)
r57: uTake2(mark(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r58: uTake2(X1,mark(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r59: uTake2(X1,X2,mark(X3),X4) -> uTake2(X1,X2,X3,X4)
r60: uTake2(X1,X2,X3,mark(X4)) -> uTake2(X1,X2,X3,X4)
r61: uTake2(active(X1),X2,X3,X4) -> uTake2(X1,X2,X3,X4)
r62: uTake2(X1,active(X2),X3,X4) -> uTake2(X1,X2,X3,X4)
r63: uTake2(X1,X2,active(X3),X4) -> uTake2(X1,X2,X3,X4)
r64: uTake2(X1,X2,X3,active(X4)) -> uTake2(X1,X2,X3,X4)
r65: uLength(mark(X1),X2) -> uLength(X1,X2)
r66: uLength(X1,mark(X2)) -> uLength(X1,X2)
r67: uLength(active(X1),X2) -> uLength(X1,X2)
r68: uLength(X1,active(X2)) -> uLength(X1,X2)

The set of usable rules consists of

  (no rules)

Take the monotone reduction pair:

  lexicographic combination of reduction pairs:
  
    1. max/plus interpretations on natural numbers:
    
      length#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1
    
    2. max/plus interpretations on natural numbers:
    
      length#_A(x1) = x1
      mark_A(x1) = x1 + 1
      active_A(x1) = x1 + 1
    

The next rules are strictly ordered:

  p1, p2

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