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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 5}
    and_A(x1,x2) = max{4, x1 + 3, x2}
    tt_A = 12
    mark#_A(x1) = max{0, x1 - 5}
    uLength_A(x1,x2) = max{x1 + 6, x2 + 16}
    mark_A(x1) = x1
    s_A(x1) = max{17, x1}
    length_A(x1) = x1 + 16
    uTake2_A(x1,x2,x3,x4) = max{x1, x2 + 11, x3 + 12, x4 + 12}
    cons_A(x1,x2) = max{x1 + 5, x2}
    isNat_A(x1) = max{5, x1 - 11}
    isNatList_A(x1) = x1 + 5
    uTake1_A(x1) = max{7, x1 + 6}
    take_A(x1,x2) = max{x1 + 11, x2 + 12}
    isNatIList_A(x1) = x1 + 5
    |0|_A = 23
    zeros_A = 28
    active_A(x1) = max{1, x1}
    nil_A = 7

The next rules are strictly ordered:

  p2, p8, p11, p12, p17, p20, p22

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: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p8: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
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#(cons(X1,X2)) -> mark#(X1)
p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p13: mark#(zeros()) -> active#(zeros())
p14: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p15: mark#(length(X)) -> active#(length(mark(X)))
p16: mark#(s(X)) -> mark#(X)
p17: mark#(s(X)) -> active#(s(mark(X)))
p18: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p19: mark#(isNat(X)) -> active#(isNat(X))
p20: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p21: mark#(isNatList(X)) -> active#(isNatList(X))
p22: active#(isNat(length(L))) -> mark#(isNatList(L))
p23: mark#(isNatIList(X)) -> active#(isNatIList(X))
p24: active#(isNat(s(N))) -> mark#(isNat(N))
p25: mark#(and(X1,X2)) -> mark#(X2)
p26: mark#(and(X1,X2)) -> mark#(X1)
p27: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p28: 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, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24, p25, p26, p27, p28}


-- 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)) -> active#(s(mark(X)))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(s(X)) -> mark#(X)
p15: mark#(length(X)) -> active#(length(mark(X)))
p16: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p17: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p18: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p19: mark#(zeros()) -> active#(zeros())
p20: mark#(cons(X1,X2)) -> mark#(X1)
p21: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p22: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p23: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p24: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p25: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p26: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p27: mark#(uTake2(X1,X2,X3,X4)) -> mark#(X1)
p28: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = x1 + 1
    and_A(x1,x2) = max{8, x1, x2}
    tt_A = 3
    mark#_A(x1) = max{5, x1 + 1}
    mark_A(x1) = x1
    isNatIList_A(x1) = x1 + 9
    isNatList_A(x1) = x1 + 3
    isNat_A(x1) = x1 + 8
    s_A(x1) = max{8, x1}
    length_A(x1) = x1 + 8
    cons_A(x1,x2) = max{x1 + 5, x2}
    zeros_A = 7
    |0|_A = 2
    take_A(x1,x2) = max{x1 + 15, x2 + 15}
    uTake2_A(x1,x2,x3,x4) = max{x1 + 5, x2 + 15, x3 + 15, x4 + 15}
    uTake1_A(x1) = x1 + 5
    uLength_A(x1,x2) = max{x1 + 5, x2 + 8}
    active_A(x1) = max{2, x1}
    nil_A = 3

The next rules are strictly ordered:

  p3, p9, p20, p27

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: mark#(isNat(X)) -> active#(isNat(X))
p9: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p10: mark#(s(X)) -> active#(s(mark(X)))
p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p12: mark#(s(X)) -> mark#(X)
p13: mark#(length(X)) -> active#(length(mark(X)))
p14: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p15: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p16: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p17: mark#(zeros()) -> active#(zeros())
p18: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p19: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p20: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p21: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p22: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p23: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p24: 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, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23, p24}


-- Reduction pair.

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

p1: 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#(uTake1(X)) -> active#(uTake1(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#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p10: mark#(zeros()) -> active#(zeros())
p11: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(length(X)) -> active#(length(mark(X)))
p15: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p16: mark#(s(X)) -> mark#(X)
p17: mark#(s(X)) -> active#(s(mark(X)))
p18: active#(isNat(s(N))) -> mark#(isNat(N))
p19: mark#(isNat(X)) -> active#(isNat(X))
p20: mark#(isNatList(X)) -> active#(isNatList(X))
p21: mark#(isNatIList(X)) -> active#(isNatIList(X))
p22: mark#(and(X1,X2)) -> mark#(X2)
p23: mark#(and(X1,X2)) -> mark#(X1)
p24: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{13, x1 + 1}
    and_A(x1,x2) = max{13, x1 + 1, x2}
    tt_A = 23
    mark#_A(x1) = x1 + 1
    uLength_A(x1,x2) = max{x1 + 13, x2 + 27}
    mark_A(x1) = x1
    s_A(x1) = max{12, x1}
    length_A(x1) = x1 + 27
    uTake2_A(x1,x2,x3,x4) = max{x1 + 10, x2 + 32, x3 + 37, x4 + 32}
    cons_A(x1,x2) = max{12, x1 + 5, x2}
    isNat_A(x1) = max{23, x1 - 14}
    isNatList_A(x1) = x1 + 12
    uTake1_A(x1) = x1 + 12
    take_A(x1,x2) = max{x1 + 32, x2 + 32}
    isNatIList_A(x1) = x1 + 20
    zeros_A = 12
    |0|_A = 6
    active_A(x1) = max{6, x1}
    nil_A = 13

The next rules are strictly ordered:

  p23

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#(uTake1(X)) -> active#(uTake1(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#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p10: mark#(zeros()) -> active#(zeros())
p11: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(length(X)) -> active#(length(mark(X)))
p15: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p16: mark#(s(X)) -> mark#(X)
p17: mark#(s(X)) -> active#(s(mark(X)))
p18: active#(isNat(s(N))) -> mark#(isNat(N))
p19: mark#(isNat(X)) -> active#(isNat(X))
p20: mark#(isNatList(X)) -> active#(isNatList(X))
p21: mark#(isNatIList(X)) -> active#(isNatIList(X))
p22: mark#(and(X1,X2)) -> mark#(X2)
p23: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, p23}


-- Reduction pair.

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

p1: 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#(zeros()) -> mark#(cons(|0|(),zeros()))
p11: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p12: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p13: mark#(s(X)) -> active#(s(mark(X)))
p14: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p15: mark#(s(X)) -> mark#(X)
p16: mark#(length(X)) -> active#(length(mark(X)))
p17: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p18: mark#(zeros()) -> active#(zeros())
p19: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p20: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p21: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p22: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p23: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 89}
    and_A(x1,x2) = 219
    tt_A = 217
    mark#_A(x1) = 130
    mark_A(x1) = 215
    isNat_A(x1) = 219
    s_A(x1) = 136
    isNatIList_A(x1) = 219
    cons_A(x1,x2) = 219
    isNatList_A(x1) = 219
    zeros_A = 219
    |0|_A = 217
    take_A(x1,x2) = 219
    uTake2_A(x1,x2,x3,x4) = 219
    length_A(x1) = 219
    uLength_A(x1,x2) = 219
    uTake1_A(x1) = 219
    active_A(x1) = 215
    nil_A = 238

The next rules are strictly ordered:

  p13

We remove them from the problem.

-- SCC decomposition.

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

p1: 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#(zeros()) -> mark#(cons(|0|(),zeros()))
p11: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p12: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p13: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p14: mark#(s(X)) -> mark#(X)
p15: mark#(length(X)) -> active#(length(mark(X)))
p16: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p17: mark#(zeros()) -> active#(zeros())
p18: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p19: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p20: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p21: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p22: 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, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22}


-- 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#(uTake1(X)) -> active#(uTake1(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#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p10: mark#(zeros()) -> active#(zeros())
p11: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(length(X)) -> active#(length(mark(X)))
p15: active#(isNatIList(cons(N,IL))) -> mark#(and(isNat(N),isNatIList(IL)))
p16: mark#(s(X)) -> mark#(X)
p17: mark#(isNat(X)) -> active#(isNat(X))
p18: active#(isNat(s(N))) -> mark#(isNat(N))
p19: mark#(isNatList(X)) -> active#(isNatList(X))
p20: mark#(isNatIList(X)) -> active#(isNatIList(X))
p21: mark#(and(X1,X2)) -> mark#(X2)
p22: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 48}
    and_A(x1,x2) = max{18, x1 - 15, x2}
    tt_A = 64
    mark#_A(x1) = max{0, x1 - 48}
    uLength_A(x1,x2) = max{x1 - 17, x2 + 10}
    mark_A(x1) = max{34, x1}
    s_A(x1) = max{46, x1 + 10}
    length_A(x1) = max{33, x1}
    uTake2_A(x1,x2,x3,x4) = max{188, x1 + 47, x2 + 152, x3 + 107, x4 + 117}
    cons_A(x1,x2) = max{x1, x2 + 10}
    isNat_A(x1) = max{40, x1 + 31}
    isNatList_A(x1) = max{49, x1 + 27}
    uTake1_A(x1) = max{84, x1 + 49}
    take_A(x1,x2) = max{177, x1 + 142, x2 + 107}
    isNatIList_A(x1) = x1 + 58
    zeros_A = 6
    |0|_A = 33
    active_A(x1) = max{34, x1}
    nil_A = 37

The next rules are strictly ordered:

  p15, p18

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#(uTake1(X)) -> active#(uTake1(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#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p10: mark#(zeros()) -> active#(zeros())
p11: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p12: mark#(cons(X1,X2)) -> active#(cons(mark(X1),X2))
p13: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p14: mark#(length(X)) -> active#(length(mark(X)))
p15: mark#(s(X)) -> mark#(X)
p16: mark#(isNat(X)) -> active#(isNat(X))
p17: mark#(isNatList(X)) -> active#(isNatList(X))
p18: mark#(isNatIList(X)) -> active#(isNatIList(X))
p19: mark#(and(X1,X2)) -> mark#(X2)
p20: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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, p13, p14, p15, p16, p17, p18, p19, p20}


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

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 155}
    and_A(x1,x2) = 230
    tt_A = 227
    mark#_A(x1) = 75
    mark_A(x1) = 225
    isNatList_A(x1) = 230
    cons_A(x1,x2) = 229
    isNat_A(x1) = 230
    isNatIList_A(x1) = 227
    zeros_A = 230
    |0|_A = 230
    take_A(x1,x2) = 230
    s_A(x1) = 229
    uTake2_A(x1,x2,x3,x4) = 230
    length_A(x1) = 230
    uLength_A(x1,x2) = 230
    uTake1_A(x1) = 230
    active_A(x1) = 225
    nil_A = 254

The next rules are strictly ordered:

  p5, p7

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: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: active#(zeros()) -> mark#(cons(|0|(),zeros()))
p6: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p7: mark#(isNatList(X)) -> active#(isNatList(X))
p8: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p9: mark#(isNat(X)) -> active#(isNat(X))
p10: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(length(X)) -> active#(length(mark(X)))
p13: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p14: mark#(zeros()) -> active#(zeros())
p15: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p16: mark#(uTake1(X)) -> active#(uTake1(mark(X)))
p17: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
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 estimated dependency graph contains the following SCCs:

  {p1, p2, p3, p4, p6, p7, p8, p9, p10, p11, p12, p13, 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#(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#(uTake1(X)) -> active#(uTake1(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#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p10: mark#(length(X)) -> active#(length(mark(X)))
p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p12: mark#(s(X)) -> mark#(X)
p13: mark#(isNat(X)) -> active#(isNat(X))
p14: mark#(isNatList(X)) -> active#(isNatList(X))
p15: mark#(and(X1,X2)) -> mark#(X2)
p16: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 16}
    and_A(x1,x2) = max{33, x1 + 17, x2}
    tt_A = 44
    mark#_A(x1) = max{16, x1 - 16}
    uLength_A(x1,x2) = max{72, x1 + 30, x2 + 70}
    mark_A(x1) = max{3, x1}
    s_A(x1) = max{71, x1}
    length_A(x1) = max{73, x1 + 70}
    uTake2_A(x1,x2,x3,x4) = max{x1 + 30, x2 + 64, x3 + 69, x4 + 64}
    cons_A(x1,x2) = max{63, x1 + 18, x2}
    isNat_A(x1) = max{22, x1 + 17}
    isNatList_A(x1) = x1 + 16
    uTake1_A(x1) = 31
    take_A(x1,x2) = max{68, x1 + 64, x2 + 64}
    isNatIList_A(x1) = x1 + 20
    active_A(x1) = max{5, x1}
    |0|_A = 27
    zeros_A = 63
    nil_A = 31

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

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

p1: 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: 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: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p11: mark#(s(X)) -> mark#(X)
p12: mark#(isNat(X)) -> active#(isNat(X))
p13: mark#(isNatList(X)) -> active#(isNatList(X))
p14: mark#(and(X1,X2)) -> mark#(X2)
p15: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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, p13, p14, p15}


-- 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#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatList(X)) -> active#(isNatList(X))
p6: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p7: mark#(isNat(X)) -> active#(isNat(X))
p8: active#(uTake2(tt(),M,N,IL)) -> mark#(cons(N,take(M,IL)))
p9: mark#(s(X)) -> mark#(X)
p10: mark#(length(X)) -> active#(length(mark(X)))
p11: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p12: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p13: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p14: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p15: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 66}
    and_A(x1,x2) = 68
    tt_A = 99
    mark#_A(x1) = 2
    mark_A(x1) = 134
    isNatList_A(x1) = 68
    cons_A(x1,x2) = 0
    isNat_A(x1) = 61
    take_A(x1,x2) = 68
    s_A(x1) = 89
    uTake2_A(x1,x2,x3,x4) = 68
    isNatIList_A(x1) = 0
    length_A(x1) = 68
    uLength_A(x1,x2) = 68
    active_A(x1) = max{134, x1 + 35}
    |0|_A = 44
    zeros_A = 11
    nil_A = 0
    uTake1_A(x1) = 11

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

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


-- 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)) -> 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#(isNatList(X)) -> active#(isNatList(X))
p12: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p13: mark#(and(X1,X2)) -> mark#(X2)
p14: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = x1 + 19
    and_A(x1,x2) = max{6, x1 - 10, x2}
    tt_A = 11
    mark#_A(x1) = x1 + 19
    uLength_A(x1,x2) = max{14, x1 + 1}
    mark_A(x1) = x1
    s_A(x1) = max{13, x1}
    length_A(x1) = 14
    uTake2_A(x1,x2,x3,x4) = max{x1 + 6, x3 + 20}
    cons_A(x1,x2) = x1 + 4
    isNat_A(x1) = 13
    isNatList_A(x1) = 13
    take_A(x1,x2) = max{x1 + 26, x2 + 16}
    isNatIList_A(x1) = 13
    active_A(x1) = max{3, x1}
    |0|_A = 3
    zeros_A = 7
    nil_A = 5
    uTake1_A(x1) = x1 + 4

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

p1: 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: mark#(length(X)) -> active#(length(mark(X)))
p8: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p9: mark#(s(X)) -> mark#(X)
p10: mark#(isNatList(X)) -> active#(isNatList(X))
p11: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p12: mark#(and(X1,X2)) -> mark#(X2)
p13: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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, p13}


-- 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#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatList(X)) -> active#(isNatList(X))
p6: active#(take(s(M),cons(N,IL))) -> mark#(uTake2(and(isNat(M),and(isNat(N),isNatIList(IL))),M,N,IL))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(length(X)) -> active#(length(mark(X)))
p9: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p11: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p12: mark#(uTake2(X1,X2,X3,X4)) -> active#(uTake2(mark(X1),X2,X3,X4))
p13: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 70}
    and_A(x1,x2) = 103
    tt_A = 0
    mark#_A(x1) = 33
    mark_A(x1) = 103
    isNatList_A(x1) = 103
    cons_A(x1,x2) = 28
    isNat_A(x1) = 0
    take_A(x1,x2) = 103
    s_A(x1) = 36
    uTake2_A(x1,x2,x3,x4) = 88
    isNatIList_A(x1) = 0
    length_A(x1) = 103
    uLength_A(x1,x2) = 103
    active_A(x1) = max{103, x1}
    |0|_A = 0
    zeros_A = 45
    nil_A = 0
    uTake1_A(x1) = 103

The next rules are strictly ordered:

  p12

We remove them from the problem.

-- SCC decomposition.

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

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

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{15, x1 + 12}
    and_A(x1,x2) = max{4, x1 - 5, x2}
    tt_A = 4
    mark#_A(x1) = x1 + 12
    uLength_A(x1,x2) = max{5, x1 + 1}
    mark_A(x1) = max{4, x1}
    s_A(x1) = max{5, x1}
    length_A(x1) = 5
    take_A(x1,x2) = max{57, x1 + 19, x2 + 28}
    cons_A(x1,x2) = max{4, x1 - 2}
    isNat_A(x1) = 9
    isNatList_A(x1) = 4
    uTake2_A(x1,x2,x3,x4) = max{25, x1 + 13, x2 + 18, x3 + 18}
    isNatIList_A(x1) = 0
    active_A(x1) = max{4, x1}
    |0|_A = 3
    zeros_A = 0
    nil_A = 3
    uTake1_A(x1) = 29

The next rules are strictly ordered:

  p7

We remove them from the problem.

-- SCC decomposition.

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

p1: 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#(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#(length(X)) -> active#(length(mark(X)))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(isNatList(X)) -> active#(isNatList(X))
p9: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p10: mark#(and(X1,X2)) -> mark#(X2)
p11: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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}


-- 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#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatList(X)) -> active#(isNatList(X))
p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(length(X)) -> active#(length(mark(X)))
p9: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p10: mark#(take(X1,X2)) -> active#(take(mark(X1),mark(X2)))
p11: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = x1 + 145
    and_A(x1,x2) = 75
    tt_A = 18
    mark#_A(x1) = 220
    mark_A(x1) = 75
    isNatList_A(x1) = 75
    cons_A(x1,x2) = 8
    isNat_A(x1) = 75
    length_A(x1) = 75
    uLength_A(x1,x2) = 75
    s_A(x1) = 23
    take_A(x1,x2) = 41
    active_A(x1) = max{75, x1}
    isNatIList_A(x1) = 29
    |0|_A = 75
    zeros_A = 63
    nil_A = 64
    uTake1_A(x1) = 75
    uTake2_A(x1,x2,x3,x4) = 75

The next rules are strictly ordered:

  p10

We remove them from the problem.

-- SCC decomposition.

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

p1: active#(and(tt(),T)) -> mark#(T)
p2: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p3: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatList(X)) -> active#(isNatList(X))
p6: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(length(X)) -> active#(length(mark(X)))
p9: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p10: 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}


-- 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#(length(X)) -> active#(length(mark(X)))
p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(isNatList(X)) -> active#(isNatList(X))
p8: active#(isNatList(cons(N,L))) -> mark#(and(isNat(N),isNatList(L)))
p9: mark#(and(X1,X2)) -> mark#(X2)
p10: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 14}
    and_A(x1,x2) = max{14, x1 - 16, x2 + 5}
    tt_A = 30
    mark#_A(x1) = max{0, x1 - 14}
    uLength_A(x1,x2) = max{x1 - 16, x2 + 6}
    mark_A(x1) = max{7, x1}
    s_A(x1) = max{13, x1 + 6}
    length_A(x1) = max{2, x1}
    cons_A(x1,x2) = max{x1, x2 + 6}
    isNat_A(x1) = max{31, x1 + 18}
    isNatList_A(x1) = x1 + 10
    active_A(x1) = max{7, x1}
    isNatIList_A(x1) = x1 + 29
    |0|_A = 6
    zeros_A = 1
    nil_A = 37
    take_A(x1,x2) = max{50, x1 + 43, x2 + 36}
    uTake1_A(x1) = max{36, x1 + 7}
    uTake2_A(x1,x2,x3,x4) = max{56, x1 + 3, x2 + 49, x3 + 10, x4 + 42}

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: 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#(length(X)) -> active#(length(mark(X)))
p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(isNatList(X)) -> active#(isNatList(X))
p8: mark#(and(X1,X2)) -> mark#(X2)
p9: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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}


-- 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#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p4: mark#(and(X1,X2)) -> mark#(X2)
p5: mark#(isNatList(X)) -> active#(isNatList(X))
p6: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p7: mark#(s(X)) -> mark#(X)
p8: mark#(length(X)) -> active#(length(mark(X)))
p9: 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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{0, x1 - 12}
    and_A(x1,x2) = 14
    tt_A = 25
    mark#_A(x1) = 2
    mark_A(x1) = 173
    length_A(x1) = 14
    cons_A(x1,x2) = 106
    uLength_A(x1,x2) = 14
    isNat_A(x1) = 37
    isNatList_A(x1) = 13
    s_A(x1) = 126
    active_A(x1) = max{173, x1 + 44}
    isNatIList_A(x1) = 39
    |0|_A = 17
    zeros_A = 0
    nil_A = 49
    take_A(x1,x2) = 129
    uTake1_A(x1) = 129
    uTake2_A(x1,x2,x3,x4) = 128

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


-- 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#(length(X)) -> active#(length(mark(X)))
p5: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p6: mark#(s(X)) -> mark#(X)
p7: mark#(and(X1,X2)) -> mark#(X2)
p8: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    active#_A(x1) = max{1, x1 - 11}
    and_A(x1,x2) = max{21, x2 + 3}
    tt_A = 30
    mark#_A(x1) = max{0, x1 - 11}
    uLength_A(x1,x2) = max{37, x1 + 13, x2 + 35}
    mark_A(x1) = max{6, x1}
    s_A(x1) = max{11, x1 + 5}
    length_A(x1) = max{38, x1 + 30}
    cons_A(x1,x2) = max{6, x2 + 5}
    isNat_A(x1) = max{30, x1 + 6}
    isNatList_A(x1) = x1 + 18
    active_A(x1) = max{6, x1}
    isNatIList_A(x1) = x1 + 38
    |0|_A = 0
    zeros_A = 0
    nil_A = 12
    take_A(x1,x2) = max{61, x1 + 55, x2 + 38}
    uTake1_A(x1) = x1
    uTake2_A(x1,x2,x3,x4) = max{66, x2 + 60, x4 + 43}

The next rules are strictly ordered:

  p1, p7

We remove them from the problem.

-- SCC decomposition.

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

p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p2: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p3: mark#(length(X)) -> active#(length(mark(X)))
p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p5: mark#(s(X)) -> mark#(X)
p6: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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}


-- Reduction pair.

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

p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p3: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p4: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p5: mark#(s(X)) -> mark#(X)
p6: 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 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:

  max/plus interpretations on natural numbers:
  
    mark#_A(x1) = max{0, x1 - 23}
    uLength_A(x1,x2) = max{x1 + 24, x2 + 41}
    active#_A(x1) = max{0, x1 - 23}
    mark_A(x1) = max{14, x1}
    length_A(x1) = max{51, x1 + 36}
    cons_A(x1,x2) = max{x1 - 6, x2 + 5}
    and_A(x1,x2) = max{13, x1 - 28, x2}
    isNat_A(x1) = max{33, x1 + 27}
    isNatList_A(x1) = x1 + 16
    tt_A = 33
    s_A(x1) = max{40, x1 + 5}
    active_A(x1) = max{14, x1}
    isNatIList_A(x1) = x1 + 24
    |0|_A = 15
    zeros_A = 9
    nil_A = 35
    take_A(x1,x2) = max{35, x1, x2 + 8}
    uTake1_A(x1) = 35
    uTake2_A(x1,x2,x3,x4) = max{40, x1 - 15, x2 + 5, x3 - 1, x4 + 13}

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: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p2: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p3: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(X2)))
p4: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p5: 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}


-- Reduction pair.

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

p1: mark#(uLength(X1,X2)) -> active#(uLength(mark(X1),X2))
p2: active#(uLength(tt(),L)) -> mark#(s(length(L)))
p3: mark#(length(X)) -> active#(length(mark(X)))
p4: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),L))
p5: mark#(and(X1,X2)) -> active#(and(mark(X1),mark(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:

  max/plus interpretations on natural numbers:
  
    mark#_A(x1) = max{83, x1 + 34}
    uLength_A(x1,x2) = max{14, x1 - 35}
    active#_A(x1) = x1 + 27
    mark_A(x1) = max{57, x1}
    tt_A = 102
    s_A(x1) = 60
    length_A(x1) = max{74, x1 - 2}
    cons_A(x1,x2) = max{56, x1}
    and_A(x1,x2) = max{93, x1 - 33, x2}
    isNat_A(x1) = 102
    isNatList_A(x1) = 102
    active_A(x1) = max{57, x1}
    isNatIList_A(x1) = 102
    |0|_A = 2
    zeros_A = 0
    nil_A = 0
    take_A(x1,x2) = max{43, x1 - 2, x2}
    uTake1_A(x1) = max{0, x1 - 102}
    uTake2_A(x1,x2,x3,x4) = max{58, x1 - 102, x3}

The next rules are strictly ordered:

  p1, p3, p5

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: active#(length(cons(N,L))) -> mark#(uLength(and(isNat(N),isNatList(L)),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:

  (no SCCs)

-- 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    isNatList#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: isNatList#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: isNatList#(mark(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:

  max/plus interpretations on natural numbers:
  
    isNatList#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    isNat#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: isNat#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: isNat#(mark(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:

  max/plus interpretations on natural numbers:
  
    isNat#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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:

  max/plus interpretations on natural numbers:
  
    and#_A(x1,x2) = x2
    mark_A(x1) = x1 + 1
    active_A(x1) = x1

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:

  max/plus interpretations on natural numbers:
  
    and#_A(x1,x2) = x2 + 1
    mark_A(x1) = max{0, x1 - 1}
    active_A(x1) = x1 + 1

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:

  max/plus interpretations on natural numbers:
  
    and#_A(x1,x2) = x1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: and#(mark(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}


-- Reduction pair.

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

p1: and#(mark(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:

  max/plus interpretations on natural numbers:
  
    and#_A(x1,x2) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    isNatIList#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: isNatIList#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: isNatIList#(mark(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:

  max/plus interpretations on natural numbers:
  
    isNatIList#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    uTake1#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: uTake1#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: uTake1#(mark(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:

  max/plus interpretations on natural numbers:
  
    uTake1#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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:

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

The next rules are strictly ordered:

  p6

We remove them from the problem.

-- SCC decomposition.

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

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

  max/plus interpretations on natural numbers:
  
    uTake2#_A(x1,x2,x3,x4) = x1 + 1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

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


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

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

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

  max/plus interpretations on natural numbers:
  
    uTake2#_A(x1,x2,x3,x4) = x4
    active_A(x1) = x1 + 1
    mark_A(x1) = max{0, x1 - 1}

The next rules are strictly ordered:

  p1

We remove them from the problem.

-- SCC decomposition.

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

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

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

  (no rules)

Take the reduction pair:

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

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

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:

  max/plus interpretations on natural numbers:
  
    uTake2#_A(x1,x2,x3,x4) = x2 + 1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

  max/plus interpretations on natural numbers:
  
    uTake2#_A(x1,x2,x3,x4) = x3
    mark_A(x1) = max{0, x1 - 1}
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: 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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: 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:

  max/plus interpretations on natural numbers:
  
    uTake2#_A(x1,x2,x3,x4) = x2
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(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:

  max/plus interpretations on natural numbers:
  
    cons#_A(x1,x2) = x2
    mark_A(x1) = x1 + 1
    active_A(x1) = x1

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:

  max/plus interpretations on natural numbers:
  
    cons#_A(x1,x2) = x2 + 1
    mark_A(x1) = max{0, x1 - 1}
    active_A(x1) = x1 + 1

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:

  max/plus interpretations on natural numbers:
  
    cons#_A(x1,x2) = x1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

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: cons#(mark(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:

  max/plus interpretations on natural numbers:
  
    cons#_A(x1,x2) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

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

and R consists of:

r1: active(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:

  max/plus interpretations on natural numbers:
  
    take#_A(x1,x2) = x2
    mark_A(x1) = x1 + 1
    active_A(x1) = x1

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:

  max/plus interpretations on natural numbers:
  
    take#_A(x1,x2) = x2 + 1
    mark_A(x1) = max{0, x1 - 1}
    active_A(x1) = x1 + 1

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:

  max/plus interpretations on natural numbers:
  
    take#_A(x1,x2) = x1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

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

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: take#(mark(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:

  max/plus interpretations on natural numbers:
  
    take#_A(x1,x2) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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:

  max/plus interpretations on natural numbers:
  
    uLength#_A(x1,x2) = x2
    mark_A(x1) = x1 + 1
    active_A(x1) = x1

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:

  max/plus interpretations on natural numbers:
  
    uLength#_A(x1,x2) = x2 + 1
    mark_A(x1) = max{0, x1 - 1}
    active_A(x1) = x1 + 1

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:

  max/plus interpretations on natural numbers:
  
    uLength#_A(x1,x2) = x1
    mark_A(x1) = x1
    active_A(x1) = x1 + 1

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: uLength#(mark(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}


-- Reduction pair.

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

p1: uLength#(mark(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:

  max/plus interpretations on natural numbers:
  
    uLength#_A(x1,x2) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    s#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: s#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: s#(mark(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:

  max/plus interpretations on natural numbers:
  
    s#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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

-- Reduction pair.

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

p1: 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 reduction pair:

  max/plus interpretations on natural numbers:
  
    length#_A(x1) = max{0, x1 - 1}
    mark_A(x1) = x1 + 1
    active_A(x1) = x1 + 2

The next rules are strictly ordered:

  p2

We remove them from the problem.

-- SCC decomposition.

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

p1: length#(mark(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 estimated dependency graph contains the following SCCs:

  {p1}


-- Reduction pair.

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

p1: length#(mark(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:

  max/plus interpretations on natural numbers:
  
    length#_A(x1) = x1
    mark_A(x1) = x1 + 1

The next rules are strictly ordered:

  p1

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